geobox 2.1.0__py3-none-any.whl → 2.2.1__py3-none-any.whl

geobox/aio/api.py

@@ -3,38 +3,35 @@ import asyncio
 import logging
 import os
 from urllib.parse import urljoin
-from typing import Dict, List, Optional, Union, Any
+from typing import Dict, List, Union, Any
 from datetime import datetime
 
-from geobox.enums import AnalysisDataType, AnalysisResampleMethod
-
-from ..api import GeoboxClient as SyncGeoboxClient
-from .vectorlayer import VectorLayer, LayerType
-from .feature import Feature
-from .file import File
-from .task import Task
-from .view import VectorLayerView
-from .tileset import Tileset
-from .raster import Raster
-from .mosaic import Mosaic
-from .model3d import Model
-from .map import Map
-from .user import User, UserRole, UserStatus, Session
-from .query import Query
-from .workflow import Workflow
-from .layout import Layout
-from .version import VectorLayerVersion
-from .tile3d import Tile3d
-from .settings import SystemSettings
-from .scene import Scene
-from .route import Routing
-from .plan import Plan
-from .dashboard import Dashboard
-from .basemap import Basemap
-from .attachment import Attachment
-from .apikey import ApiKey
-from .log import Log
-from .usage import Usage, UsageScale, UsageParam
+from .vectorlayer import AsyncVectorLayer, LayerType
+from .feature import AsyncFeature
+from .file import AsyncFile
+from .task import AsyncTask
+from .view import AsyncVectorLayerView
+from .tileset import AsyncTileset
+from .raster import AsyncRaster
+from .mosaic import AsyncMosaic
+from .model3d import AsyncModel
+from .map import AsyncMap
+from .user import AsyncUser, UserRole, UserStatus, AsyncSession
+from .query import AsyncQuery
+from .workflow import AsyncWorkflow
+from .layout import AsyncLayout
+from .version import AsyncVectorLayerVersion
+from .tile3d import AsyncTile3d
+from .settings import AsyncSystemSettings
+from .scene import AsyncScene
+from .route import AsyncRouting
+from .plan import AsyncPlan
+from .dashboard import AsyncDashboard
+from .basemap import AsyncBasemap
+from .attachment import AsyncAttachment
+from .apikey import AsyncApiKey
+from .log import AsyncLog
+from .usage import AsyncUsage, UsageScale, UsageParam
 from ..exception import AuthenticationError, ApiRequestError, NotFoundError, ValidationError, ServerError, AuthorizationError
 from ..utils import join_url_params
 
@@ -118,17 +115,17 @@ class AsyncRequestSession:
         return original_content_type
 
 
-class AsyncGeoboxClient(SyncGeoboxClient):
+class AsyncGeoboxClient:
     """
     An async class to interact with the Geobox API.
     """
     def __init__(self,
-                host: str = 'https://api.geobox.ir',
-                ver: str = 'v1/',
-                username: str = None,
-                password: str = None,
-                access_token: str = None, 
-                apikey: str = None):
+        host: str = 'https://api.geobox.ir',
+        ver: str = 'v1/',
+        username: str = None,
+        password: str = None,
+        access_token: str = None, 
+        apikey: str = None):
         """
         Constructs all the necessary attributes for the Api object.
         """
@@ -438,7 +435,21 @@ class AsyncGeoboxClient(SyncGeoboxClient):
         return await self._make_request(HttpMethods.DELETE, endpoint, payload, is_json)
 
 
-    async def get_vectors(self, **kwargs) -> Union[List['VectorLayer'], int]:
+    @property
+    def raster_analysis(self):
+        from .raster_analysis import AsyncRasterAnalysis
+
+        return AsyncRasterAnalysis(self)
+
+
+    @property
+    def vector_tool(self):
+        from .vector_tool import AsyncVectorTool
+
+        return AsyncVectorTool(self)
+
+
+    async def get_vectors(self, **kwargs) -> Union[List['AsyncVectorLayer'], int]:
         """
         [async] Get a list of vector layers with optional filtering and pagination.
         
@@ -456,24 +467,24 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             shared (bool): Whether to return shared layers. default is False.
                 
         Returns:
-            List[VectorLayer] | int: A list of VectorLayer instances or the layers count if return_count is True.
+            List[AsyncVectorLayer] | int: A list of VectorLayer instances or the layers count if return_count is True.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     layers = await client.get_vectors(include_settings=True, 
-            ...                                         skip=0, 
-            ...                                         limit=100, 
-            ...                                         return_count=False, 
-            ...                                         search="my_layer",
-            ...                                         search_fields="name, description",
-            ...                                         order_by="name",
-            ...                                         shared=True)
-        """
-        return await VectorLayer.get_vectors(self, **kwargs)
+            ...         skip=0, 
+            ...         limit=100, 
+            ...         return_count=False, 
+            ...         search="my_layer",
+            ...         search_fields="name, description",
+            ...         order_by="name",
+            ...         shared=True)
+        """
+        return await AsyncVectorLayer.get_vectors(self, **kwargs)
     
 
-    async def get_vector(self, uuid: str, user_id: int = None) -> 'VectorLayer':
+    async def get_vector(self, uuid: str, user_id: int = None) -> 'AsyncVectorLayer':
         """
         [async] Get a specific vector layer by its UUID.
         
@@ -492,10 +503,10 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             >>> async with AsyncGeoboxClient() as client:
             >>>     layer = await client.get_vector(uuid="12345678-1234-5678-1234-567812345678")
         """
-        return await VectorLayer.get_vector(self, uuid, user_id)
+        return await AsyncVectorLayer.get_vector(self, uuid, user_id)
     
 
-    async def get_vectors_by_ids(self, ids: List[int], user_id: int = None, include_settings: bool = False) -> List['VectorLayer']:
+    async def get_vectors_by_ids(self, ids: List[int], user_id: int = None, include_settings: bool = False) -> List['AsyncVectorLayer']:
         """
         [async] Get vector layers by their IDs.
 
@@ -505,24 +516,24 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             include_settings (bool, optional): Whether to include the layer settings. default is False.
 
         Returns:
-            List[VectorLayer]: The list of VectorLayer instances.
+            List[AsyncVectorLayer]: The list of VectorLayer instances.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     layers = await client.get_vectors_by_ids(ids=[1, 2, 3])
         """
-        return await VectorLayer.get_vectors_by_ids(self, ids, user_id, include_settings)
+        return await AsyncVectorLayer.get_vectors_by_ids(self, ids, user_id, include_settings)
 
 
     async def create_vector(self, 
-                     name: str, 
-                     layer_type: 'LayerType', 
-                     display_name: str = None, 
-                     description: str = None,
-                     has_z: bool = False,
-                     temporary: bool = False,
-                     fields: List = None) -> 'VectorLayer':
+        name: str, 
+        layer_type: 'LayerType', 
+        display_name: str = None, 
+        description: str = None,
+        has_z: bool = False,
+        temporary: bool = False,
+        fields: List = None) -> 'AsyncVectorLayer':
         """
         [async] Create a new vector layer.
         
@@ -536,7 +547,7 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             fields (List, optional): List of field definitions for the layer. default is None.
             
         Returns:
-            VectorLayer: The newly created layer instance.
+            AsyncVectorLayer: The newly created layer instance.
             
         Raises:
             ValidationError: If the layer data is invalid.
@@ -545,16 +556,16 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     layer = await client.create_vector(name="my_layer", 
-            ...                                         layer_type=LayerType.Point,
-            ...                                         display_name="My Layer",
-            ...                                         description="This is a description of my layer",
-            ...                                         has_z=False,
-            ...                                         fields=[{"name": "my_field", "datatype": "FieldTypeString"}])
+            ...         layer_type=LayerType.Point,
+            ...         display_name="My Layer",
+            ...         description="This is a description of my layer",
+            ...         has_z=False,
+            ...         fields=[{"name": "my_field", "datatype": "FieldTypeString"}])
         """
-        return await VectorLayer.create_vector(self, name=name, layer_type=layer_type, display_name=display_name, description=description, has_z=has_z, temporary=temporary, fields=fields)
+        return await AsyncVectorLayer.create_vector(self, name=name, layer_type=layer_type, display_name=display_name, description=description, has_z=has_z, temporary=temporary, fields=fields)
 
 
-    async def get_vector_by_name(self, name: str, user_id: int = None) -> Union['VectorLayer', None]:
+    async def get_vector_by_name(self, name: str, user_id: int = None) -> Union['AsyncVectorLayer', None]:
         """
         [async] Get a vector layer by name
 
@@ -563,17 +574,17 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             user_id (int, optional): specific user. privileges required.
 
         Returns:
-            VectorLayer | None: returns the vector if a vector matches the given name, else None
+            AsyncVectorLayer | None: returns the vector if a vector matches the given name, else None
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     layer = await client.get_vector_by_name(name='test')
         """
-        return await VectorLayer.get_vector_by_name(self, name, user_id)
+        return await AsyncVectorLayer.get_vector_by_name(self, name, user_id)
     
 
-    async def get_files(self, **kwargs) -> Union[List['File'], int]:
+    async def get_files(self, **kwargs) -> Union[List['AsyncFile'], int]:
         """
         [async] Retrieves a list of files.
 
@@ -589,17 +600,17 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             shared (bool): Whether to return shared files. default is False.
             
         Returns:
-            List[File] | int: A list of File objects or the total number of results.
+            List[AsyncFile] | int: A list of File objects or the total number of results.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     files = await client.get_files(search_fields='name', search='GIS', order_by='name', skip=10, limit=10)
         """
-        return await File.get_files(self, **kwargs)
+        return await AsyncFile.get_files(self, **kwargs)
 
 
-    async def get_file(self, uuid: str) -> 'File':
+    async def get_file(self, uuid: str) -> 'AsyncFile':
         """
         [async] Retrieves a file by its UUID.
 
@@ -607,7 +618,7 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             uuid (str, optional): The UUID of the file.
 
         Returns:
-            File: The retrieved file instance.
+            AsyncFile: The retrieved file instance.
 
         Raises:
             NotFoundError: If the file with the specified UUID is not found.
@@ -617,10 +628,10 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             >>> async with AsyncGeoboxClient() as client:
             >>>     file = await client.get_file(uuid="12345678-1234-5678-1234-567812345678")
         """
-        return await File.get_file(self, uuid=uuid)
+        return await AsyncFile.get_file(self, uuid=uuid)
     
 
-    async def get_files_by_name(self, name: str, user_id: int = None) -> List['File']:
+    async def get_files_by_name(self, name: str, user_id: int = None) -> List['AsyncFile']:
         """
         [async] Get files by name
 
@@ -629,17 +640,17 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             user_id (int, optional): specific user. privileges required.
 
         Returns:
-            List[File]: returns files that matches the given name
+            List[AsyncFile]: returns files that matches the given name
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     files = await client.get_files_by_name(name='test')
         """
-        return await File.get_files_by_name(self, name, user_id)
+        return await AsyncFile.get_files_by_name(self, name, user_id)
 
 
-    async def upload_file(self, path: str, user_id: int = None, scan_archive: bool = True) -> 'File':
+    async def upload_file(self, path: str, user_id: int = None, scan_archive: bool = True) -> 'AsyncFile':
         """
         [async] Upload a file to the GeoBox API.
 
@@ -649,7 +660,7 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             scan_archive (bool, optional): Whether to scan the archive for layers. default: True
 
         Returns:
-            File: The uploaded file instance.
+            AsyncFile: The uploaded file instance.
 
         Raises:
             ValueError: If the file type is invalid.
@@ -660,10 +671,10 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             >>> async with AsyncGeoboxClient() as client:
             >>>     file = await client.upload_file(path='path/to/file.shp')
         """
-        return await File.upload_file(self, path=path, user_id=user_id, scan_archive=scan_archive)
+        return await AsyncFile.upload_file(self, path=path, user_id=user_id, scan_archive=scan_archive)
 
 
-    async def get_tasks(self, **kwargs) -> Union[List['Task'], int]:
+    async def get_tasks(self, **kwargs) -> Union[List['AsyncTask'], int]:
         """
         [async] Get a list of tasks
 
@@ -680,17 +691,17 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             shared (bool): Whether to return shared tasks. default is False.
 
         Returns:
-            List[Task] | int: The list of task objects or the count of the tasks if return_count is True.
+            List[AsyncTask] | int: The list of task objects or the count of the tasks if return_count is True.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     tasks = await client.get_tasks()
         """
-        return await Task.get_tasks(self, **kwargs)
+        return await AsyncTask.get_tasks(self, **kwargs)
 
 
-    async def get_task(self, uuid: str) -> 'Task':
+    async def get_task(self, uuid: str) -> 'AsyncTask':
         """
         [async] Gets a task.
 
@@ -698,17 +709,17 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             uuid (str): The UUID of the task.
 
         Returns:
-            Task: The task object.
+            AsyncTask: The task object.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     task = await client.get_task(uuid="12345678-1234-5678-1234-567812345678")
         """
-        return await Task.get_task(self, uuid)
+        return await AsyncTask.get_task(self, uuid)
 
 
-    async def get_views(self, **kwargs) -> Union[List['VectorLayerView'], int]:
+    async def get_views(self, **kwargs) -> Union[List['AsyncVectorLayerView'], int]:
         """
         [async] Get vector layer views.
 
@@ -726,25 +737,25 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             shared(bool): Whether to return shared views. default is False.
 
         Returns:
-            list[VectorLayerView] | int: A list of VectorLayerView instances or the layer views count if return_count is True.
+            list[AsyncVectorLayerView] | int: A list of VectorLayerView instances or the layer views count if return_count is True.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     views = await client.get_views(layer_id=1,
-            ...                                     include_settings=True,
-            ...                                     search="test",
-            ...                                     search_fields="name",
-            ...                                     order_by="name A",
-            ...                                     return_count=False,
-            ...                                     skip=0,
-            ...                                     limit=10,
-            ...                                     shared=True)
+            ...         include_settings=True,
+            ...         search="test",
+            ...         search_fields="name",
+            ...         order_by="name A",
+            ...         return_count=False,
+            ...         skip=0,
+            ...         limit=10,
+            ...         shared=True)
         """
-        return await VectorLayerView.get_views(self, **kwargs)
+        return await AsyncVectorLayerView.get_views(self, **kwargs)
 
 
-    async def get_views_by_ids(self, ids: List[int], user_id: int = None, include_settings: bool = False) -> List['VectorLayerView']:
+    async def get_views_by_ids(self, ids: List[int], user_id: int = None, include_settings: bool = False) -> List['AsyncVectorLayerView']:
         """
         [async] Get vector layer views by their IDs.
 
@@ -754,17 +765,17 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             include_settings (bool, optional): Whether to include the settings of the vector layer views. default is False.
 
         Returns:
-            List[VectorLayerView]: A list of VectorLayerView instances.
+            List[AsyncVectorLayerView]: A list of VectorLayerView instances.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     views = await client.get_views_by_ids(ids=[1,2,3])
         """
-        return await VectorLayerView.get_views_by_ids(self, ids, user_id, include_settings)
+        return await AsyncVectorLayerView.get_views_by_ids(self, ids, user_id, include_settings)
     
 
-    async def get_view(self, uuid: str, user_id: int = None) -> 'VectorLayerView':
+    async def get_view(self, uuid: str, user_id: int = None) -> 'AsyncVectorLayerView':
         """
         [async] Get a specific vector layer view by its UUID.
 
@@ -773,17 +784,17 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             user_id (int, optional): Specific user. privileges required.
 
         Returns:    
-            VectorLayerView: A VectorLayerView instance.
+            AsyncVectorLayerView: A VectorLayerView instance.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     view = await client.get_view(uuid="12345678-1234-5678-1234-567812345678")
         """
-        return await VectorLayerView.get_view(self, uuid, user_id)
+        return await AsyncVectorLayerView.get_view(self, uuid, user_id)
 
 
-    async def get_view_by_name(self, name: str, user_id: int = None) -> Union['VectorLayerView', None]:
+    async def get_view_by_name(self, name: str, user_id: int = None) -> Union['AsyncVectorLayerView', None]:
         """
         [async] Get a view by name
 
@@ -792,18 +803,18 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             user_id (int, optional): specific user. privileges required.
 
         Returns:
-            VectorLayerView | None: returns the view if a view matches the given name, else None
+            AsyncVectorLayerView | None: returns the view if a view matches the given name, else None
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     view = await client.get_view_by_name(name='test')
         """
-        return await VectorLayerView.get_view_by_name(self, name, user_id)
+        return await AsyncVectorLayerView.get_view_by_name(self, name, user_id)
 
 
-    async def create_tileset(self, name: str, layers: List[Union['VectorLayer', 'VectorLayerView']], display_name: str = None, description: str = None,
-                        min_zoom: int = None, max_zoom: int = None, user_id: int = None) -> 'Tileset':
+    async def create_tileset(self, name: str, layers: List[Union['AsyncVectorLayer', 'AsyncVectorLayerView']], display_name: str = None, description: str = None,
+                        min_zoom: int = None, max_zoom: int = None, user_id: int = None) -> 'AsyncTileset':
         """
         [async] Create a new tileset.
 
@@ -817,7 +828,7 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             user_id (int, optional): Specific user. privileges required.
 
         Returns:
-            Tileset: The created tileset instance.
+            AsyncTileset: The created tileset instance.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
@@ -825,23 +836,23 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             >>>     layer = await client.get_vector(uuid="12345678-1234-5678-1234-567812345678")
             >>>     view = await client.get_view(uuid="12345678-1234-5678-1234-567812345678")
             >>>     tileset = await client.create_tileset(name="your_tileset_name", 
-            ...                                             display_name="Your Tileset", 
-            ...                                             description="Your description", 
-            ...                                             min_zoom=0, 
-            ...                                             max_zoom=14, 
-            ...                                             layers=[layer, view])
-        """
-        return await Tileset.create_tileset(api=self, 
-                                      name=name, 
-                                      layers=layers, 
-                                      display_name=display_name, 
-                                      description=description, 
-                                      min_zoom=min_zoom, 
-                                      max_zoom=max_zoom, 
-                                      user_id=user_id)
+            ...        display_name="Your Tileset", 
+            ...        description="Your description", 
+            ...        min_zoom=0, 
+            ...        max_zoom=14, 
+            ...        layers=[layer, view])
+        """
+        return await AsyncTileset.create_tileset(api=self, 
+            name=name, 
+            layers=layers, 
+            display_name=display_name, 
+            description=description, 
+            min_zoom=min_zoom, 
+            max_zoom=max_zoom, 
+            user_id=user_id)
 
 
-    async def get_tilesets(self, **kwargs) -> Union[List['Tileset'], int]:
+    async def get_tilesets(self, **kwargs) -> Union[List['AsyncTileset'], int]:
         """
         [async] Retrieves a list of tilesets.
 
@@ -857,7 +868,7 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             shared (bool): Whether to return shared tilesets. default is False.
 
         Returns:
-            List[Tileset] | int: A list of Tileset instances or the total number of tilesets
+            List[AsyncTileset] | int: A list of Tileset instances or the total number of tilesets
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
@@ -868,10 +879,10 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             ...         limit=10,
             ...     )
         """
-        return await Tileset.get_tilesets(self, **kwargs)
+        return await AsyncTileset.get_tilesets(self, **kwargs)
 
 
-    async def get_tilesets_by_ids(self, ids: List[int], user_id: int = None) -> List['Tileset']:
+    async def get_tilesets_by_ids(self, ids: List[int], user_id: int = None) -> List['AsyncTileset']:
         """
         [async] Retrieves a list of tilesets by their IDs.
 
@@ -880,17 +891,17 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             user_id (int, optional): Specific user. privileges required.
 
         Returns:
-            List[Tileset]: A list of Tileset instances.
+            List[AsyncTileset]: A list of Tileset instances.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     tilesets = await client.get_tilesets_by_ids(ids=['123', '456'])
         """
-        return await Tileset.get_tilesets_by_ids(self, ids, user_id)
+        return await AsyncTileset.get_tilesets_by_ids(self, ids, user_id)
 
 
-    async def get_tileset(self, uuid: str) -> 'Tileset':
+    async def get_tileset(self, uuid: str) -> 'AsyncTileset':
         """
         [async] Retrieves a tileset by its UUID.
 
@@ -898,17 +909,17 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             uuid (str): The UUID of the tileset.
 
         Returns:
-            Tileset: The retrieved tileset instance.
+            AsyncTileset: The retrieved tileset instance.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     tileset = await client.get_tileset(uuid="12345678-1234-5678-1234-567812345678")
         """
-        return await Tileset.get_tileset(self, uuid)
+        return await AsyncTileset.get_tileset(self, uuid)
 
 
-    async def get_tileset_by_name(self, name: str, user_id: int = None) -> Union['Tileset', None]:
+    async def get_tileset_by_name(self, name: str, user_id: int = None) -> Union['AsyncTileset', None]:
         """
         [async] Get a tileset by name
 
@@ -917,17 +928,17 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             user_id (int, optional): specific user. privileges required.
 
         Returns:
-            Tileset | None: returns the tileset if a tileset matches the given name, else None
+            AsyncTileset | None: returns the tileset if a tileset matches the given name, else None
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     tileset = await client.get_tileset_by_name(name='test')
         """
-        return await Tileset.get_tileset_by_name(self, name, user_id)
+        return await AsyncTileset.get_tileset_by_name(self, name, user_id)
     
 
-    async def get_rasters(self, **kwargs) -> Union[List['Raster'], int]:
+    async def get_rasters(self, **kwargs) -> Union[List['AsyncRaster'], int]:
         """
         [async] Get all rasters.
 
@@ -944,17 +955,17 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             shared (bool): whether to return shared rasters. default is False.
 
         Returns:
-            List[Raster] | int: A list of Raster objects or the total count of rasters.
+            List[AsyncRaster] | int: A list of Raster objects or the total count of rasters.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     rasters = await client.get_rasters(terrain=True, q="name LIKE '%GIS%'")
         """
-        return await Raster.get_rasters(self, **kwargs)
+        return await AsyncRaster.get_rasters(self, **kwargs)
 
 
-    async def get_rasters_by_ids(self, ids: List[int], user_id: int = None) -> List['Raster']:
+    async def get_rasters_by_ids(self, ids: List[int], user_id: int = None) -> List['AsyncRaster']:
         """
         [async] Get rasters by their IDs.
 
@@ -963,17 +974,17 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             user_id (int, optional): specific user. privileges required.
 
         Returns:
-            List['Raster']: A list of Raster objects.
+            List['AsyncRaster']: A list of Raster objects.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     rasters = await client.get_rasters_by_ids(ids=['123', '456'])
         """ 
-        return await Raster.get_rasters_by_ids(self, ids, user_id)
+        return await AsyncRaster.get_rasters_by_ids(self, ids, user_id)
 
 
-    async def get_raster(self, uuid: str) -> 'Raster':
+    async def get_raster(self, uuid: str) -> 'AsyncRaster':
         """
         [async] Get a raster by its UUID.
 
@@ -982,17 +993,17 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             user_id (int, optional): specific user. privileges required.
 
         Returns:
-            Raster: A Raster object.
+            AsyncRaster: A Raster object.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     raster = await client.get_raster(uuid="12345678-1234-5678-1234-567812345678")
         """
-        return await Raster.get_raster(self, uuid)    
+        return await AsyncRaster.get_raster(self, uuid)    
 
 
-    async def get_raster_by_name(self, name: str, user_id: int = None) -> Union['Raster', None]:
+    async def get_raster_by_name(self, name: str, user_id: int = None) -> Union['AsyncRaster', None]:
         """
         [async] Get a raster by name
 
@@ -1001,17 +1012,17 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             user_id (int, optional): specific user. privileges required.
 
         Returns:
-            Raster | None: returns the raster if a raster matches the given name, else None
+            AsyncRaster | None: returns the raster if a raster matches the given name, else None
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     raster = await client.get_raster_by_name(name='test')
         """
-        return await Raster.get_raster_by_name(self, name, user_id)
+        return await AsyncRaster.get_raster_by_name(self, name, user_id)
 
 
-    async def get_mosaics(self, **kwargs) -> Union[List['Mosaic'], int]:
+    async def get_mosaics(self, **kwargs) -> Union[List['AsyncMosaic'], int]:
         """
         [async] Get a list of mosaics.
 
@@ -1027,17 +1038,17 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             shared (bool): Whether to return shared mosaics. default is False.
 
         Returns:
-            List['Mosaic'] | int: A list of Mosaic instances or the number of mosaics.
+            List['AsyncMosaic'] | int: A list of Mosaic instances or the number of mosaics.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     mosaics = await client.get_mosaics(q="name LIKE '%GIS%'")
         """
-        return await Mosaic.get_mosaics(self, **kwargs)
+        return await AsyncMosaic.get_mosaics(self, **kwargs)
 
 
-    async def get_mosaics_by_ids(self, ids: List[int], user_id: int = None) -> List['Mosaic']:
+    async def get_mosaics_by_ids(self, ids: List[int], user_id: int = None) -> List['AsyncMosaic']:
         """
         [async] Get mosaics by their IDs.
 
@@ -1046,23 +1057,23 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             user_id (int, optional): specific user. privileges required.
 
         Returns:
-            List[Mosaic]: A list of Mosaic instances.
+            List[AsyncMosaic]: A list of Mosaic instances.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     mosaics = await client.get_mosaics_by_ids(ids=['1, 2, 3'])
         """
-        return await Mosaic.get_mosaics_by_ids(self, ids, user_id)
+        return await AsyncMosaic.get_mosaics_by_ids(self, ids, user_id)
 
 
     async def create_mosaic(self, 
-                      name:str,
-                      display_name: str = None,
-                      description: str = None,
-                      pixel_selection: str = None,
-                      min_zoom: int = None,
-                      user_id: int = None) -> 'Mosaic':
+        name:str,
+        display_name: str = None,
+        description: str = None,
+        pixel_selection: str = None,
+        min_zoom: int = None,
+        user_id: int = None) -> 'AsyncMosaic':
         """
         [async] Create New Raster Mosaic
 
@@ -1075,17 +1086,17 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             user_id (int, optional): specific user. privileges required.
 
         Returns:
-            Mosaic: The created mosaic.
+            AsyncMosaic: The created mosaic.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     mosaic = await client.create_mosaic(name='mosaic_name')
         """
-        return await Mosaic.create_mosaic(self, name, display_name, description, pixel_selection, min_zoom, user_id)
+        return await AsyncMosaic.create_mosaic(self, name, display_name, description, pixel_selection, min_zoom, user_id)
 
 
-    async def get_mosaic(self, uuid: str, user_id: int = None) -> 'Mosaic':
+    async def get_mosaic(self, uuid: str, user_id: int = None) -> 'AsyncMosaic':
         """
         [async] Get a mosaic by uuid.
 
@@ -1094,17 +1105,17 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             user_id (int, optional): specific user. privileges required.
 
         Returns:
-            Mosaic: The mosaic object.
+            AsyncMosaic: The mosaic object.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     mosaic = await client.get_mosaic(uuid="12345678-1234-5678-1234-567812345678")
         """      
-        return await Mosaic.get_mosaic(self, uuid, user_id)
+        return await AsyncMosaic.get_mosaic(self, uuid, user_id)
 
 
-    async def get_mosaic_by_name(self, name: str, user_id: int = None) -> Union['Mosaic', None]:
+    async def get_mosaic_by_name(self, name: str, user_id: int = None) -> Union['AsyncMosaic', None]:
         """
         [async] Get a mosaic by name
 
@@ -1113,17 +1124,17 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             user_id (int, optional): specific user. privileges required.
 
         Returns:
-            Mosaic | None: returns the mosaic if a mosaic matches the given name, else None
+            AsyncMosaic | None: returns the mosaic if a mosaic matches the given name, else None
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     mosaic = await client.get_mosaic_by_name(name='test')
         """
-        return await Mosaic.get_mosaic_by_name(self, name, user_id)
+        return await AsyncMosaic.get_mosaic_by_name(self, name, user_id)
 
 
-    async def get_models(self, **kwargs) -> Union[List['Model'], int]:
+    async def get_models(self, **kwargs) -> Union[List['AsyncModel'], int]:
         """
         [async] Get a list of models with optional filtering and pagination.
 
@@ -1139,23 +1150,23 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             shared (bool): Whether to return shared models. default is False.
 
         Returns:
-            List[Model] | int: A list of Model objects or the count number.
+            List[AsyncModel] | int: A list of Model objects or the count number.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     models = await client.get_models(search="my_model",
-            ...                                         search_fields="name, description",
-            ...                                         order_by="name A",
-            ...                                         return_count=True,
-            ...                                         skip=0,
-            ...                                         limit=10,
-            ...                                         shared=False)
-        """
-        return await Model.get_models(self, **kwargs)
+            ...         search_fields="name, description",
+            ...         order_by="name A",
+            ...         return_count=True,
+            ...         skip=0,
+            ...         limit=10,
+            ...         shared=False)
+        """
+        return await AsyncModel.get_models(self, **kwargs)
     
 
-    async def get_model(self, uuid: str, user_id: int = None) -> 'Model':
+    async def get_model(self, uuid: str, user_id: int = None) -> 'AsyncModel':
         """
         [async] Get a model by its UUID.
 
@@ -1164,7 +1175,7 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             user_id (int, optional): Specific user. privileges required.
 
         Returns:
-            Model: The model object.
+            AsyncModel: The model object.
 
         Raises:
             NotFoundError: If the model with the specified UUID is not found.
@@ -1174,10 +1185,10 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             >>> async with AsyncGeoboxClient() as client:
             >>>     model = await client.get_model(uuid="12345678-1234-5678-1234-567812345678")
         """
-        return await Model.get_model(self, uuid, user_id)
+        return await AsyncModel.get_model(self, uuid, user_id)
 
 
-    async def get_model_by_name(self, name: str, user_id: int = None) -> Union['Model', None]:
+    async def get_model_by_name(self, name: str, user_id: int = None) -> Union['AsyncModel', None]:
         """
         [async] Get a model by name
 
@@ -1186,17 +1197,17 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             user_id (int, optional): specific user. privileges required.
 
         Returns:
-            Model | None: returns the model if a model matches the given name, else None
+            AsyncModel | None: returns the model if a model matches the given name, else None
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     model = await client.get_model_by_name(name='test')
         """
-        return await Model.get_model_by_name(self, name, user_id)
+        return await AsyncModel.get_model_by_name(self, name, user_id)
     
     
-    async def get_maps(self, **kwargs) -> Union[List['Map'], int]:
+    async def get_maps(self, **kwargs) -> Union[List['AsyncMap'], int]:
         """
         [async] Get list of maps with optional filtering and pagination.
 
@@ -1212,24 +1223,24 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             shared (bool): Whether to return shared maps. default is False.
 
         Returns:
-            List[Map] | int: A list of Map instances or the total number of maps.
+            List[AsyncMap] | int: A list of Map instances or the total number of maps.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     maps = await client.get_maps(q="name LIKE '%My Map%'")
         """
-        return await Map.get_maps(self, **kwargs)
+        return await AsyncMap.get_maps(self, **kwargs)
     
 
     async def create_map(self, 
-                   name: str, 
-                   display_name: str = None, 
-                   description: str = None,
-                   extent: List[float] = None,
-                   thumbnail: str = None,
-                   style: Dict = None,
-                   user_id: int = None) -> 'Map':
+        name: str, 
+        display_name: str = None, 
+        description: str = None,
+        extent: List[float] = None,
+        thumbnail: str = None,
+        style: Dict = None,
+        user_id: int = None) -> 'AsyncMap':
         """
         [async] Create a new map.
 
@@ -1243,7 +1254,7 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             user_id (int, optional): Specific user. privileges required.
 
         Returns:
-            Map: The newly created map instance.
+            AsyncMap: The newly created map instance.
 
         Raises:
             ValidationError: If the map data is invalid.
@@ -1253,10 +1264,10 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             >>> async with AsyncGeoboxClient() as client:
             >>>     map = await client.create_map(name="my_map", display_name="My Map", description="This is a description of my map", extent=[10, 20, 30, 40], thumbnail="https://example.com/thumbnail.png", style={"type": "style"})
         """
-        return await Map.create_map(self, name, display_name, description, extent, thumbnail, style, user_id)
+        return await AsyncMap.create_map(self, name, display_name, description, extent, thumbnail, style, user_id)
     
 
-    async def get_map(self, uuid: str, user_id: int = None) -> 'Map':
+    async def get_map(self, uuid: str, user_id: int = None) -> 'AsyncMap':
         """
         [async] Get a map by its UUID.
 
@@ -1265,7 +1276,7 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             user_id (int, optional): Specific user. privileges required.
 
         Returns:
-            Map: The map object.
+            AsyncMap: The map object.
 
         Raises:
             NotFoundError: If the map with the specified UUID is not found.
@@ -1275,10 +1286,10 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             >>> async with AsyncGeoboxClient() as client:
             >>>     map = await client.get_map(uuid="12345678-1234-5678-1234-567812345678")
         """
-        return await Map.get_map(self, uuid, user_id)
+        return await AsyncMap.get_map(self, uuid, user_id)
 
 
-    async def get_map_by_name(self, name: str, user_id: int = None) -> Union['Map', None]:
+    async def get_map_by_name(self, name: str, user_id: int = None) -> Union['AsyncMap', None]:
         """
         [async] Get a map by name
 
@@ -1287,17 +1298,17 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             user_id (int, optional): specific user. privileges required.
 
         Returns:
-            Map | None: returns the map if a map matches the given name, else None
+            AsyncMap | None: returns the map if a map matches the given name, else None
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     map = await client.get_map_by_name(name='test')
         """
-        return await Map.get_map_by_name(self, name, user_id)
+        return await AsyncMap.get_map_by_name(self, name, user_id)
     
 
-    async def get_queries(self, **kwargs) -> Union[List['Query'], int]:
+    async def get_queries(self, **kwargs) -> Union[List['AsyncQuery'], int]:
         """
         [async] Get Queries
 
@@ -1313,17 +1324,17 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             shared (bool): Whether to return shared queries. default is False.
 
         Returns:
-            List[Query] | int: list of queries or the number of queries.
+            List[AsyncQuery] | int: list of queries or the number of queries.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     queries = await client.get_queries()
         """
-        return await Query.get_queries(self, **kwargs)
+        return await AsyncQuery.get_queries(self, **kwargs)
     
 
-    async def create_query(self, name: str, display_name: str = None, description: str = None, sql: str = None, params: List = None) -> 'Query':
+    async def create_query(self, name: str, display_name: str = None, description: str = None, sql: str = None, params: List = None) -> 'AsyncQuery':
         """
         [async] Creates a new query.
 
@@ -1335,17 +1346,17 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             params (list, optional): The parameters for the SQL statement.
 
         Returns:
-            Query: The created query instance.
+            AsyncQuery: The created query instance.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     query = await client.create_query(name='query_name', display_name='Query Name', sql='SELECT * FROM some_layer')
         """
-        return await Query.create_query(self, name, display_name, description, sql, params)
+        return await AsyncQuery.create_query(self, name, display_name, description, sql, params)
     
 
-    async def get_query(self, uuid: str, user_id: int = None) -> 'Query':
+    async def get_query(self, uuid: str, user_id: int = None) -> 'AsyncQuery':
         """
         [async] Retrieves a query by its UUID.
 
@@ -1354,17 +1365,17 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             user_id (int, optional): specific user ID. privileges required.
 
         Returns:
-            Query: The retrieved query instance.
+            AsyncQuery: The retrieved query instance.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     query = await client.get_query(uuid="12345678-1234-5678-1234-567812345678")
         """
-        return await Query.get_query(self, uuid, user_id)
+        return await AsyncQuery.get_query(self, uuid, user_id)
 
 
-    async def get_query_by_name(self, name: str, user_id: int = None) -> Union['Query', None]:
+    async def get_query_by_name(self, name: str, user_id: int = None) -> Union['AsyncQuery', None]:
         """
         [async] Get a query by name
 
@@ -1373,17 +1384,17 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             user_id (int, optional): specific user. privileges required.
 
         Returns:
-            Query | None: returns the query if a query matches the given name, else None
+            AsyncQuery | None: returns the query if a query matches the given name, else None
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     query = await client.get_query_by_name(name='test')
         """
-        return await Query.get_query_by_name(self, name, user_id)
+        return await AsyncQuery.get_query_by_name(self, name, user_id)
     
 
-    async def get_system_queries(self, **kwargs) -> List['Query']:
+    async def get_system_queries(self, **kwargs) -> List['AsyncQuery']:
         """
         [async] Returns the system queries as a list of Query objects.
 
@@ -1399,17 +1410,17 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             shared (bool): whether to return shared queries. default is False.
         
         Returns:
-            List[Query]: list of system queries.
+            List[AsyncQuery]: list of system queries.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     queries = await client.get_system_queries()
         """
-        return await Query.get_system_queries(self, **kwargs)
+        return await AsyncQuery.get_system_queries(self, **kwargs)
     
 
-    async def get_users(self, **kwrags) -> Union[List['User'], int]:
+    async def get_users(self, **kwrags) -> Union[List['AsyncUser'], int]:
         """
         [async] Retrieves a list of users (Permission Required)
 
@@ -1426,14 +1437,14 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             shared (bool): Whether to return shared maps. default is False.
 
         Returns:
-            List[User] | int: list of users or the count number.
+            List[AsyncUser] | int: list of users or the count number.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     users = await client.get_users()
         """
-        return await User.get_users(self, **kwrags)
+        return await AsyncUser.get_users(self, **kwrags)
     
 
     async def create_user(self,
@@ -1444,7 +1455,7 @@ class AsyncGeoboxClient(SyncGeoboxClient):
                     first_name: str,
                     last_name: str,
                     mobile: str,
-                    status: 'UserStatus') -> 'User':
+                    status: 'UserStatus') -> 'AsyncUser':
         """
         [async] Create a User (Permission Required)
 
@@ -1459,24 +1470,24 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             status (UserStatus): the status of the user.
 
         Returns:
-            User: the user object.
+            AsyncUser: the user object.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     user = await client.create_user(username="user1",
-            ...                                 email="user1@example.com",
-            ...                                 password="P@ssw0rd",
-            ...                                 role=UserRole.ACCOUNT_ADMIN,
-            ...                                 first_name="user 1",
-            ...                                 last_name="user 1",
-            ...                                 mobile="+98 9120123456",
-            ...                                 status=UserStatus.ACTIVE)
-        """
-        return await User.create_user(self, username, email, password, role, first_name, last_name, mobile, status)
+            ...         email="user1@example.com",
+            ...         password="P@ssw0rd",
+            ...         role=UserRole.ACCOUNT_ADMIN,
+            ...         first_name="user 1",
+            ...         last_name="user 1",
+            ...         mobile="+98 9120123456",
+            ...         status=UserStatus.ACTIVE)
+        """
+        return await AsyncUser.create_user(self, username, email, password, role, first_name, last_name, mobile, status)
     
 
-    async def search_users(self, search: str = None, skip: int = 0, limit: int = 10) -> List['User']:
+    async def search_users(self, search: str = None, skip: int = 0, limit: int = 10) -> List['AsyncUser']:
         """
         [async] Get list of users based on the search term.
 
@@ -1486,17 +1497,17 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             limit (int, optional): Number of items to return. default is 10.
 
         Returns:
-            List[User]: A list of User instances.
+            List[AsyncUser]: A list of User instances.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     users = await client.get_users(search="John")
         """
-        return await User.search_users(self, search, skip, limit)
+        return await AsyncUser.search_users(self, search, skip, limit)
     
 
-    async def get_user(self, user_id: str = 'me') -> 'User':
+    async def get_user(self, user_id: str = 'me') -> 'AsyncUser':
         """
         [async] Get a user by its id (Permission Required)
 
@@ -1516,15 +1527,15 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             get the current user
             >>>     user = await client.get_user()
         """
-        return await User.get_user(self, user_id)
+        return await AsyncUser.get_user(self, user_id)
     
 
-    async def get_my_sessions(self) -> List['Session']:
+    async def get_my_sessions(self) -> List['AsyncSession']:
         """
         [async] Get a list of user available sessions (Permission Required)
 
         Returns:
-            List[Session]: list of user sessions.
+            List[AsyncSession]: list of user sessions.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
@@ -1535,7 +1546,7 @@ class AsyncGeoboxClient(SyncGeoboxClient):
         return await user.get_sessions()
     
 
-    async def get_workflows(self, **kwargs) -> Union[List['Workflow'], int]:
+    async def get_workflows(self, **kwargs) -> Union[List['AsyncWorkflow'], int]:
         """
         [async] Get list of workflows with optional filtering and pagination.
 
@@ -1551,23 +1562,23 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             shared (bool): Whether to return shared workflows. default is False.
 
         Returns:
-            List[Workflow] | int: A list of workflow instances or the total number of workflows.
+            List[AsyncWorkflow] | int: A list of workflow instances or the total number of workflows.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     workflows = await client.get_workflows(q="name LIKE '%My workflow%'")
         """
-        return await Workflow.get_workflows(self, **kwargs)
+        return await AsyncWorkflow.get_workflows(self, **kwargs)
     
 
     async def create_workflow(self,
-                    name: str, 
-                    display_name: str = None, 
-                    description: str = None, 
-                    settings: Dict = {}, 
-                    thumbnail: str = None, 
-                    user_id: int = None) -> 'Workflow':
+        name: str, 
+        display_name: str = None, 
+        description: str = None, 
+        settings: Dict = {}, 
+        thumbnail: str = None, 
+        user_id: int = None) -> 'AsyncWorkflow':
         """
         [async] Create a new workflow.
 
@@ -1580,7 +1591,7 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             user_id (int): Specific user. privileges workflow.
 
         Returns:
-            Workflow: The newly created workflow instance.
+            AsyncWorkflow: The newly created workflow instance.
 
         Raises:
             ValidationError: If the workflow data is invalid.
@@ -1590,10 +1601,10 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             >>> async with AsyncGeoboxClient() as client:
             >>>     workflow = await client.create_workflow(name="my_workflow")
         """
-        return await Workflow.create_workflow(self, name, display_name, description, settings, thumbnail, user_id)
+        return await AsyncWorkflow.create_workflow(self, name, display_name, description, settings, thumbnail, user_id)
 
 
-    async def get_workflow(self, uuid: str, user_id: int = None) -> 'Workflow':
+    async def get_workflow(self, uuid: str, user_id: int = None) -> 'AsyncWorkflow':
         """
         [async] Get a workflow by its UUID.
 
@@ -1602,7 +1613,7 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             user_id (int): Specific user. privileges required.
 
         Returns:
-            Workflow: The workflow object.
+            AsyncWorkflow: The workflow object.
 
         Raises:
             NotFoundError: If the workflow with the specified UUID is not found.
@@ -1612,10 +1623,10 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             >>> async with AsyncGeoboxClient() as client:
             >>>     workflow = await client.get_workflow(uuid="12345678-1234-5678-1234-567812345678")
         """
-        return await Workflow.get_workflow(self, uuid, user_id)
+        return await AsyncWorkflow.get_workflow(self, uuid, user_id)
 
 
-    async def get_workflow_by_name(self, name: str, user_id: int = None) -> Union['Workflow', None]:
+    async def get_workflow_by_name(self, name: str, user_id: int = None) -> Union['AsyncWorkflow', None]:
         """
         [async] Get a workflow by name
 
@@ -1624,17 +1635,17 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             user_id (int, optional): specific user. privileges required.
 
         Returns:
-            Workflow | None: returns the workflow if a workflow matches the given name, else None
+            AsyncWorkflow | None: returns the workflow if a workflow matches the given name, else None
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     workflow = await client.get_workflow_by_name(name='test')
         """
-        return await Workflow.get_workflow_by_name(self, name, user_id)
+        return await AsyncWorkflow.get_workflow_by_name(self, name, user_id)
     
 
-    async def get_versions(self, **kwargs) -> Union[List['VectorLayerVersion'], int]:
+    async def get_versions(self, **kwargs) -> Union[List['AsyncVectorLayerVersion'], int]:
         """
         [async] Get list of versions with optional filtering and pagination.
 
@@ -1651,17 +1662,17 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             shared (bool): Whether to return shared versions. default is False.
 
         Returns:
-            List[VectorLayerVersion] | int: A list of vector layer version instances or the total number of versions.
+            List[AsyncVectorLayerVersion] | int: A list of vector layer version instances or the total number of versions.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     versions = await client.get_versions(q="name LIKE '%My version%'")
         """
-        return await VectorLayerVersion.get_versions(self, **kwargs)
+        return await AsyncVectorLayerVersion.get_versions(self, **kwargs)
     
 
-    async def get_version(self, uuid: str, user_id: int = None) -> 'VectorLayerVersion':
+    async def get_version(self, uuid: str, user_id: int = None) -> 'AsyncVectorLayerVersion':
         """
         [async] Get a version by its UUID.
 
@@ -1670,7 +1681,7 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             user_id (int, optional): Specific user. privileges required.
 
         Returns:
-            VectorLayerVersion: The vector layer version object.
+            AsyncVectorLayerVersion: The vector layer version object.
 
         Raises:
             NotFoundError: If the version with the specified UUID is not found.
@@ -1680,10 +1691,10 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             >>> async with AsyncGeoboxClient() as client:
             >>>     version = await client.get_version(uuid="12345678-1234-5678-1234-567812345678")
         """
-        return await VectorLayerVersion.get_version(self, uuid, user_id)
+        return await AsyncVectorLayerVersion.get_version(self, uuid, user_id)
 
 
-    async def get_version_by_name(self, name: str, user_id: int = None) -> 'VectorLayerVersion':
+    async def get_version_by_name(self, name: str, user_id: int = None) -> 'AsyncVectorLayerVersion':
         """
         [async] Get a version by name
 
@@ -1692,17 +1703,17 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             user_id (int, optional): specific user. privileges required.
 
         Returns:
-            VectorLayerVersion | None: returns the version if a version matches the given name, else None
+            AsyncVectorLayerVersion | None: returns the version if a version matches the given name, else None
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     version = await client.get_version_by_name(name='test')
         """
-        return await VectorLayerVersion.get_version_by_name(self, name, user_id)
+        return await AsyncVectorLayerVersion.get_version_by_name(self, name, user_id)
     
 
-    async def get_layouts(self, **kwargs) -> Union[List['Layout'], int]:
+    async def get_layouts(self, **kwargs) -> Union[List['AsyncLayout'], int]:
         """
         [async] Get list of layouts with optional filtering and pagination.
 
@@ -1718,23 +1729,23 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             shared (bool): Whether to return shared layouts. default is False.
 
         Returns:
-            List[Layout] | int: A list of layout instances or the total number of layouts.
+            List[AsyncLayout] | int: A list of layout instances or the total number of layouts.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     layouts = await client.get_layouts(q="name LIKE '%My layout%'")
         """
-        return await Layout.get_layouts(self, **kwargs)
+        return await AsyncLayout.get_layouts(self, **kwargs)
     
 
     async def create_layout(self,
-                    name: str, 
-                    display_name: str = None, 
-                    description: str = None, 
-                    settings: Dict = {}, 
-                    thumbnail: str = None, 
-                    user_id: int = None) -> 'Layout':
+        name: str, 
+        display_name: str = None, 
+        description: str = None, 
+        settings: Dict = {}, 
+        thumbnail: str = None, 
+        user_id: int = None) -> 'AsyncLayout':
         """
         [async] Create a new layout.
 
@@ -1747,7 +1758,7 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             user_id (int): Specific user. privileges layout.
 
         Returns:
-            Layout: The newly created layout instance.
+            AsyncLayout: The newly created layout instance.
 
         Raises:
             ValidationError: If the layout data is invalid.
@@ -1757,10 +1768,10 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             >>> async with AsyncGeoboxClient() as client:
             >>>     layout = await client.create_layout(name="my_layout")
         """
-        return await Layout.create_layout(self, name, display_name, description, settings, thumbnail, user_id)
+        return await AsyncLayout.create_layout(self, name, display_name, description, settings, thumbnail, user_id)
 
 
-    async def get_layout(self, uuid: str, user_id: int = None) -> 'Layout':
+    async def get_layout(self, uuid: str, user_id: int = None) -> 'AsyncLayout':
         """
         [async] Get a layout by its UUID.
 
@@ -1769,7 +1780,7 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             user_id (int): Specific user. privileges required.
 
         Returns:
-            Layout: The layout object.
+            AsyncLayout: The layout object.
 
         Raises:
             NotFoundError: If the layout with the specified UUID is not found.
@@ -1779,10 +1790,10 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             >>> async with AsyncGeoboxClient() as client:
             >>>     layout = await client.get_layout(uuid="12345678-1234-5678-1234-567812345678")
         """
-        return await Layout.get_layout(self, uuid, user_id)
+        return await AsyncLayout.get_layout(self, uuid, user_id)
 
 
-    async def get_layout_by_name(self, name: str, user_id: int = None) -> Union['Layout', None]:
+    async def get_layout_by_name(self, name: str, user_id: int = None) -> Union['AsyncLayout', None]:
         """
         [async] Get a layout by name
 
@@ -1791,17 +1802,17 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             user_id (int, optional): specific user. privileges required.
 
         Returns:
-            Layout | None: returns the layout if a layout matches the given name, else None
+            AsyncLayout | None: returns the layout if a layout matches the given name, else None
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     layout = await client.get_layout_by_name(name='test')
         """
-        return await Layout.get_layout_by_name(self, name, user_id)
+        return await AsyncLayout.get_layout_by_name(self, name, user_id)
 
 
-    async def get_3dtiles(self, **kwargs) -> Union[List['Tile3d'], int]:
+    async def get_3dtiles(self, **kwargs) -> Union[List['AsyncTile3d'], int]:
         """
         [async] Get list of 3D Tiles with optional filtering and pagination.
 
@@ -1817,17 +1828,17 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             shared (bool): Whether to return shared maps. default is False.
 
         Returns:
-            List[Tile3d] | int: A list of 3D Tile instances or the total number of 3D Tiles.
+            List[AsyncTile3d] | int: A list of 3D Tile instances or the total number of 3D Tiles.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     tiles = await client.get_3dtiles(q="name LIKE '%My tile%'")
         """ 
-        return await Tile3d.get_3dtiles(self, **kwargs)
+        return await AsyncTile3d.get_3dtiles(self, **kwargs)
     
 
-    async def get_3dtile(self, uuid: str, user_id: int = None) -> 'Tile3d':
+    async def get_3dtile(self, uuid: str, user_id: int = None) -> 'AsyncTile3d':
         """
         [async] Get a 3D Tile by its UUID.
 
@@ -1836,7 +1847,7 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             user_id (int): Specific user. privileges required.
 
         Returns:
-            Tile3d: The 3D Tile object.
+            AsyncTile3d: The 3D Tile object.
 
         Raises:
             NotFoundError: If the 3D Tile with the specified UUID is not found.
@@ -1846,10 +1857,10 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             >>> async with AsyncGeoboxClient() as client:
             >>>     tile = await client.get_3dtile(uuid="12345678-1234-5678-1234-567812345678")
         """ 
-        return await Tile3d.get_3dtile(self, uuid, user_id)
+        return await AsyncTile3d.get_3dtile(self, uuid, user_id)
 
 
-    async def get_3dtile_by_name(self, name: str, user_id: int = None) -> Union['Tile3d', None]:
+    async def get_3dtile_by_name(self, name: str, user_id: int = None) -> Union['AsyncTile3d', None]:
         """
         [async] Get a 3dtile by name
 
@@ -1858,32 +1869,32 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             user_id (int, optional): specific user. privileges required.
 
         Returns:
-            Tile3d | None: returns the 3dtile if a 3dtile matches the given name, else None
+            AsyncTile3d | None: returns the 3dtile if a 3dtile matches the given name, else None
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     tile3d = await client.get_3dtile_by_name(name='test')
         """
-        return await Tile3d.get_3dtile_by_name(self, name, user_id)
+        return await AsyncTile3d.get_3dtile_by_name(self, name, user_id)
     
 
-    async def get_system_settings(self) -> 'SystemSettings':
+    async def get_system_settings(self) -> 'AsyncSystemSettings':
         """
         [async] Get System Settings object (Permission Required).
 
         Returns:
-            SystemSetting: the system settings object.
+            AsyncSystemSetting: the system settings object.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     setting = await client.get_system_settings()
         """
-        return await SystemSettings.get_system_settings(self)
+        return await AsyncSystemSettings.get_system_settings(self)
 
 
-    async def get_scenes(self, **kwargs) -> Union[List['Scene'], int]:
+    async def get_scenes(self, **kwargs) -> Union[List['AsyncScene'], int]:
         """
         [async] Get list of scenes with optional filtering and pagination.
 
@@ -1899,23 +1910,23 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             shared (bool): Whether to return shared scenes. default is False.
 
         Returns:
-            List[Scene] | int: A list of scene instances or the total number of scenes.
+            List[AsyncScene] | int: A list of scene instances or the total number of scenes.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     scenes = await client.get_scenes(q="name LIKE '%My scene%'")
         """
-        return await Scene.get_scenes(self, **kwargs)
+        return await AsyncScene.get_scenes(self, **kwargs)
     
 
     async def create_scene(self, 
-                     name: str, 
-                     display_name: str = None, 
-                     description: str = None, 
-                     settings: Dict = {}, 
-                     thumbnail: str = None, 
-                     user_id: int = None) -> 'Scene':
+        name: str, 
+        display_name: str = None, 
+        description: str = None, 
+        settings: Dict = {}, 
+        thumbnail: str = None, 
+        user_id: int = None) -> 'AsyncScene':
         """
         [async] Create a new scene.
 
@@ -1928,7 +1939,7 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             user_id (int, optional): Specific user. privileges required.
 
         Returns:
-            Scene: The newly created scene instance.
+            AsyncScene: The newly created scene instance.
 
         Raises:
             ValidationError: If the scene data is invalid.
@@ -1938,16 +1949,16 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             >>> async with AsyncGeoboxClient() as client:
             >>>     scene = await client.create_scene(name="my_scene")
         """
-        return await Scene.create_scene(self, 
-                                  name, 
-                                  display_name, 
-                                  description, 
-                                  settings, 
-                                  thumbnail, 
-                                  user_id)
+        return await AsyncScene.create_scene(self, 
+            name, 
+            display_name, 
+            description, 
+            settings, 
+            thumbnail, 
+            user_id)
     
 
-    async def get_scene(self, uuid: str, user_id: int = None) -> 'Scene':
+    async def get_scene(self, uuid: str, user_id: int = None) -> 'AsyncScene':
         """
         [async] Get a scene by its UUID.
 
@@ -1956,7 +1967,7 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             user_id (int, optional): Specific user. privileges required.
 
         Returns:
-            Scene: The scene object.
+            AsyncScene: The scene object.
 
         Raises:
             NotFoundError: If the scene with the specified UUID is not found.
@@ -1966,10 +1977,10 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             >>> async with AsyncGeoboxClient() as client:
             >>>     scene = await client.get_scene(uuid="12345678-1234-5678-1234-567812345678")
         """
-        return await Scene.get_scene(self, uuid, user_id)
+        return await AsyncScene.get_scene(self, uuid, user_id)
 
 
-    async def get_scene_by_name(self, name: str, user_id: int = None) -> Union['Scene', None]:
+    async def get_scene_by_name(self, name: str, user_id: int = None) -> Union['AsyncScene', None]:
         """
         [async] Get a scene by name
 
@@ -1978,14 +1989,14 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             user_id (int, optional): specific user. privileges required.
 
         Returns:
-            Scene | None: returns the scene if a scene matches the given name, else None
+            AsyncScene | None: returns the scene if a scene matches the given name, else None
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     scene = await client.get_scene_by_name(name='test')
         """
-        return await Scene.get_scene_by_name(self, name, user_id)
+        return await AsyncScene.get_scene_by_name(self, name, user_id)
 
 
     async def route(self, stops: str, **kwargs) -> Dict:
@@ -2009,16 +2020,16 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     route = await client.route(stops="53,33;56,36",
-            ...                                 alternatives=True,
-            ...                                 steps=True,
-            ...                                 geometries=RoutingGeometryType.geojson,
-            ...                                 overview=RoutingOverviewLevel.full,
-            ...                                 annotations=True)
+            ...         alternatives=True,
+            ...         steps=True,
+            ...         geometries=RoutingGeometryType.geojson,
+            ...         overview=RoutingOverviewLevel.full,
+            ...         annotations=True)
         """
-        return await Routing.route(self, stops, **kwargs)
+        return await AsyncRouting.route(self, stops, **kwargs)
     
 
-    async def get_plans(self, **kwargs) -> Union[List['Plan'], int]:
+    async def get_plans(self, **kwargs) -> Union[List['AsyncPlan'], int]:
         """
         [async] Get list of plans with optional filtering and pagination.
 
@@ -2034,30 +2045,30 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             shared (bool): Whether to return shared plans. default is False.
 
         Returns:
-            List[Plan] | int: A list of plan instances or the total number of plans.
+            List[AsyncPlan] | int: A list of plan instances or the total number of plans.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     plans = await client.get_plans(q="name LIKE '%My plan%'")
         """
-        return await Plan.get_plans(self, **kwargs)
+        return await AsyncPlan.get_plans(self, **kwargs)
     
 
     async def create_plan(self,
-                    name: str,
-                    plan_color: str,
-                    storage: int,
-                    concurrent_tasks: int,
-                    daily_api_calls: int,
-                    monthly_api_calls: int,
-                    daily_traffic: int,
-                    monthly_traffic: int,
-                    daily_process: int,
-                    monthly_process: int,
-                    number_of_days: int = None,
-                    display_name: str = None,
-                    description: str = None) -> 'Plan':
+        name: str,
+        plan_color: str,
+        storage: int,
+        concurrent_tasks: int,
+        daily_api_calls: int,
+        monthly_api_calls: int,
+        daily_traffic: int,
+        monthly_traffic: int,
+        daily_process: int,
+        monthly_process: int,
+        number_of_days: int = None,
+        display_name: str = None,
+        description: str = None) -> 'AsyncPlan':
         """
         [async] Create a new plan.
 
@@ -2077,7 +2088,7 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             description (str, optional): description of the plan.
 
         Returns:
-            Plan: The newly created plan instance.
+            AsyncPlan: The newly created plan instance.
 
         Raises:
             ValidationError: If the plan data is invalid.
@@ -2086,36 +2097,36 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     plan = await client.create_plan(name="new_plan",
-            ...                                 display_name=" New Plan",
-            ...                                 description="new plan description",
-            ...                                 plan_color="#000000",
-            ...                                 storage=10,
-            ...                                 concurrent_tasks=10,
-            ...                                 daily_api_calls=10,
-            ...                                 monthly_api_calls=10,
-            ...                                 daily_traffic=10,
-            ...                                 monthly_traffic=10,
-            ...                                 daily_process=10,
-            ...                                 monthly_process=10,
-            ...                                 number_of_days=10)
-        """
-        return await Plan.create_plan(self,
-                                name,
-                                plan_color,
-                                storage,
-                                concurrent_tasks,
-                                daily_api_calls,
-                                monthly_api_calls,
-                                daily_traffic,
-                                monthly_traffic,
-                                daily_process,
-                                monthly_process,
-                                number_of_days,
-                                display_name,
-                                description)
+            ...         display_name=" New Plan",
+            ...         description="new plan description",
+            ...         plan_color="#000000",
+            ...         storage=10,
+            ...         concurrent_tasks=10,
+            ...         daily_api_calls=10,
+            ...         monthly_api_calls=10,
+            ...         daily_traffic=10,
+            ...         monthly_traffic=10,
+            ...         daily_process=10,
+            ...         monthly_process=10,
+            ...         number_of_days=10)
+        """
+        return await AsyncPlan.create_plan(self,
+            name,
+            plan_color,
+            storage,
+            concurrent_tasks,
+            daily_api_calls,
+            monthly_api_calls,
+            daily_traffic,
+            monthly_traffic,
+            daily_process,
+            monthly_process,
+            number_of_days,
+            display_name,
+            description)
     
 
-    async def get_plan(self, plan_id: int) -> 'Plan':
+    async def get_plan(self, plan_id: int) -> 'AsyncPlan':
         """
         [async] Get a plan by its id.
 
@@ -2123,7 +2134,7 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             plan_id (int): The id of the plan to get.
 
         Returns:
-            Plan: The plan object
+            AsyncPlan: The plan object
 
         Raises:
             NotFoundError: If the plan with the specified id is not found.
@@ -2133,10 +2144,10 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             >>> async with AsyncGeoboxClient() as client:
             >>>     plan = await client.get_plan(plan_id=1)
         """
-        return await Plan.get_plan(self, plan_id)
+        return await AsyncPlan.get_plan(self, plan_id)
     
 
-    async def get_plan_by_name(self, name: str) -> Union['Plan', None]:
+    async def get_plan_by_name(self, name: str) -> Union['AsyncPlan', None]:
         """
         [async] Get a plan by name
 
@@ -2145,17 +2156,17 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             name (str): the name of the plan to get
 
         Returns:
-            Plan | None: returns the plan if a plan matches the given name, else None
+            AsyncPlan | None: returns the plan if a plan matches the given name, else None
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     plan = await client.get_plan_by_name(name='test')
         """
-        return await Plan.get_plan_by_name(self, name)
+        return await AsyncPlan.get_plan_by_name(self, name)
     
 
-    async def get_dashboards(self, **kwargs) -> Union[List['Dashboard'], int]:
+    async def get_dashboards(self, **kwargs) -> Union[List['AsyncDashboard'], int]:
         """
         [async] Get list of Dashboards
 
@@ -2171,23 +2182,23 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             shared (bool): Whether to return shared Dashboards. default is False.
 
         Returns:
-            List[Dashboard] | int: A list of Dashboard instances or the total number of Dashboards.
+            List[AsyncDashboard] | int: A list of Dashboard instances or the total number of Dashboards.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     dashboards = await client.get_dashboards()
         """
-        return await Dashboard.get_dashboards(self, **kwargs)
+        return await AsyncDashboard.get_dashboards(self, **kwargs)
     
 
     async def create_dashboard(self,
-                     name: str, 
-                     display_name: str = None, 
-                     description: str = None, 
-                     settings: Dict = {}, 
-                     thumbnail: str = None, 
-                     user_id: int = None) -> 'Dashboard':
+        name: str, 
+        display_name: str = None, 
+        description: str = None, 
+        settings: Dict = {}, 
+        thumbnail: str = None, 
+        user_id: int = None) -> 'AsyncDashboard':
         """
         [async] Create a new Dashboard.
 
@@ -2200,7 +2211,7 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             user_id (int, optional): Specific user. privileges required.
 
         Returns:
-            Dashboard: The newly created Dashboard instance.
+            AsyncDashboard: The newly created Dashboard instance.
 
         Raises:
             ValidationError: If the Dashboard data is invalid.
@@ -2210,16 +2221,16 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             >>> async with AsyncGeoboxClient() as client:
             >>>     dashboard = await client.create_dashboard(name="my_dashboard")
         """
-        return await Dashboard.create_dashboard(self,
-                                          name,
-                                          display_name,
-                                          description,
-                                          settings,
-                                          thumbnail,
-                                          user_id)
+        return await AsyncDashboard.create_dashboard(self,
+            name,
+            display_name,
+            description,
+            settings,
+            thumbnail,
+            user_id)
     
 
-    async def get_dashboard(self, uuid: str, user_id: int = None) -> 'Dashboard':
+    async def get_dashboard(self, uuid: str, user_id: int = None) -> 'AsyncDashboard':
         """
         [async] Get a Dashboard by its UUID.
 
@@ -2228,7 +2239,7 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             user_id (int, optional): Specific user. privileges required.
 
         Returns:
-            Dashboard: The dashboard object.
+            AsyncDashboard: The dashboard object.
 
         Raises:
             NotFoundError: If the Dashboard with the specified UUID is not found.
@@ -2238,10 +2249,10 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             >>> async with AsyncGeoboxClient() as client:
             >>>     dashboard = await client.get_dashboard(uuid="12345678-1234-5678-1234-567812345678")
         """
-        return await Dashboard.get_dashboard(self, uuid, user_id)
+        return await AsyncDashboard.get_dashboard(self, uuid, user_id)
 
 
-    async def get_dashboard_by_name(self, name: str, user_id: int = None) -> Union['Dashboard', None]:
+    async def get_dashboard_by_name(self, name: str, user_id: int = None) -> Union['AsyncDashboard', None]:
         """
         [async] Get a dashboard by name
 
@@ -2250,32 +2261,32 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             user_id (int, optional): specific user. privileges required.
 
         Returns:
-            Dashboard | None: returns the dashboard if a dashboard matches the given name, else None
+            AsyncDashboard | None: returns the dashboard if a dashboard matches the given name, else None
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     dashboard = await client.get_dashboard_by_name(name='test')
         """
-        return await Dashboard.get_dashboard_by_name(self, name, user_id)
+        return await AsyncDashboard.get_dashboard_by_name(self, name, user_id)
     
 
-    async def get_basemaps(self) -> List['Basemap']:
+    async def get_basemaps(self) -> List['AsyncBasemap']:
         """
         [async] Get a list of basemaps
 
         Returns:
-            List[BaseMap]: list of basemaps.
+            List[AsyncBaseMap]: list of basemaps.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     basemaps = await client.get_basemaps()
         """
-        return await Basemap.get_basemaps(self)
+        return await AsyncBasemap.get_basemaps(self)
     
 
-    async def get_basemap(self, name: str) -> 'Basemap':
+    async def get_basemap(self, name: str) -> 'AsyncBasemap':
         """
         [async] Get a basemap object
 
@@ -2283,7 +2294,7 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             name: the basemap name
 
         Returns:
-            Basemap: the basemap object
+            AsyncBasemap: the basemap object
 
         Raises:
             NotFoundError: if the base,ap with the specified name not found
@@ -2293,7 +2304,7 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             >>> async with AsyncGeoboxClient() as client:
             >>>     basemap = await client.get_basemap(name='test')
         """
-        return await Basemap.get_basemap(self, name)
+        return await AsyncBasemap.get_basemap(self, name)
     
 
     async def proxy_basemap(self, url: str) -> None:
@@ -2311,15 +2322,15 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             >>> async with AsyncGeoboxClient() as client:
             >>>     await client.proxy_basemap(url='proxy_server_url')
         """
-        return await Basemap.proxy_basemap(self, url)
+        return await AsyncBasemap.proxy_basemap(self, url)
     
 
-    async def get_attachments(self, resource: Union['Map', 'VectorLayer', 'VectorLayerView'], **kwargs) -> List['Attachment']:
+    async def get_attachments(self, resource: Union['AsyncMap', 'AsyncVectorLayer', 'AsyncVectorLayerView'], **kwargs) -> List['AsyncAttachment']:
         """
         [async] Get the resouces attachments
 
         Args:
-            resource (Map | VectorLayer | VectorLayerView): options are: Map, Vector, View objects
+            resource (AsyncMap | AsyncVectorLayer | AsyncVectorLayerView): options are: Map, Vector, View objects
 
         Keyword Args:
             element_id (str): the id of the element with attachment.
@@ -2330,7 +2341,7 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             return_count (bool): Whether to return total count. default is False.
 
         Returns:
-            List[Attachment] | int: A list of attachments instances or the total number of attachments.
+            List[AsyncAttachment] | int: A list of attachments instances or the total number of attachments.
 
         Raises:
             TypeError: if the resource type is not supported
@@ -2342,18 +2353,18 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             >>>     map = maps[0]
             >>>     attachments = await client.get_attachments(resource=map)
         """
-        return await Attachment.get_attachments(self, resource=resource, **kwargs)
+        return await AsyncAttachment.get_attachments(self, resource=resource, **kwargs)
     
 
     async def create_attachment(self,
-                     name: str, 
-                     loc_x: int,
-                     loc_y: int,
-                     resource: Union['Map', 'VectorLayer', 'VectorLayerView'],
-                     file: 'File',
-                     feature: 'Feature' = None,
-                     display_name: str = None, 
-                     description: str = None, ) -> 'Attachment':
+        name: str, 
+        loc_x: int,
+        loc_y: int,
+        resource: Union['AsyncMap', 'AsyncVectorLayer', 'AsyncVectorLayerView'],
+        file: 'AsyncFile',
+        feature: 'AsyncFeature' = None,
+        display_name: str = None, 
+        description: str = None, ) -> 'AsyncAttachment':
         """
         [async] Create a new Attachment.
 
@@ -2361,9 +2372,9 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             name (str): The name of the scene.
             loc_x (int): x parameter of the attachment location.
             loc_y (int): y parameter of the attachment location.
-            resource (Map | VectorLayer | VectorLayerView): the resource object.
-            file (File): the file object.
-            feature (Feature, optional): the feature object.
+            resource (AsyncMap | AsyncVectorLayer | AsyncVectorLayerView): the resource object.
+            file (AsyncFile): the file object.
+            feature (AsyncFeature, optional): the feature object.
             display_name (str, optional): The display name of the scene.
             description (str, optional): The description of the scene.
 
@@ -2380,23 +2391,23 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             >>>     feature = await layer.get_feature(feature_id=1)
             >>>     file = await client.get_file(uuid="12345678-1234-5678-1234-567812345678")
             >>>     attachment = await client.create_attachment(name="my_attachment", 
-            ...                                                 loc_x=30, 
-            ...                                                 loc_y=50, 
-            ...                                                 resource=layer, 
-            ...                                                 file=file, 
-            ...                                                 feature=feature, 
-            ...                                                 display_name="My Attachment", 
-            ...                                                 description="Attachment Description")
-        """
-        return await Attachment.create_attachment(self,
-                                            name,
-                                            loc_x,
-                                            loc_y,
-                                            resource,
-                                            file,
-                                            feature,
-                                            display_name,
-                                            description)
+            ...         loc_x=30, 
+            ...         loc_y=50, 
+            ...         resource=layer, 
+            ...         file=file, 
+            ...         feature=feature, 
+            ...         display_name="My Attachment", 
+            ...         description="Attachment Description")
+        """
+        return await AsyncAttachment.create_attachment(self,
+            name,
+            loc_x,
+            loc_y,
+            resource,
+            file,
+            feature,
+            display_name,
+            description)
     
 
     async def update_attachment(self, attachment_id: int, **kwargs) -> Dict:
@@ -2424,10 +2435,10 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             >>> async with AsyncGeoboxClient() as client:
             >>>     await client.update_attachment(attachment_id=1, display_name="New Display Name")
         """
-        return await Attachment.update_attachment(self, attachment_id, **kwargs)
+        return await AsyncAttachment.update_attachment(self, attachment_id, **kwargs)
     
 
-    async def get_apikeys(self, **kwargs) -> List['ApiKey']:
+    async def get_apikeys(self, **kwargs) -> List['AsyncApiKey']:
         """
         [async] Get a list of apikeys
 
@@ -2438,15 +2449,18 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             limit (int): Maximum number of layers to return. default is 10.
             user_id (int): Specific user. privileges required.
         
+        Returns: 
+            AsyncApiKey: list of apikey objects
+    
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     apikeys = await client.get_apikeys()
         """
-        return await ApiKey.get_apikeys(self, **kwargs)
+        return await AsyncApiKey.get_apikeys(self, **kwargs)
     
 
-    async def create_apikey(self, name: str, user_id: int = None) -> 'ApiKey':
+    async def create_apikey(self, name: str, user_id: int = None) -> 'AsyncApiKey':
         """
         [async] Create an ApiKey
 
@@ -2455,17 +2469,17 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             user_id (int, optional): Specific user. privileges required.
 
         Returns: 
-            ApiKey: the apikey object
+            AsyncApiKey: the apikey object
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     apikey = await client.create_apikey(name='test')
         """
-        return await ApiKey.create_apikey(self, name, user_id)
+        return await AsyncApiKey.create_apikey(self, name, user_id)
     
 
-    async def get_apikey(self, key_id: int) -> 'ApiKey':
+    async def get_apikey(self, key_id: int) -> 'AsyncApiKey':
         """
         [async] Get an ApiKey
 
@@ -2473,17 +2487,17 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             key_id (str): the id of the apikey.
 
         Returns:
-            ApiKey: the ApiKey object
+            AsyncApiKey: the ApiKey object
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     apikey = await client.get_apikey(key_id=1) 
         """
-        return await ApiKey.get_apikey(self, key_id)
+        return await AsyncApiKey.get_apikey(self, key_id)
 
 
-    async def get_apikey_by_name(self, name: str, user_id: int = None) -> 'ApiKey':
+    async def get_apikey_by_name(self, name: str, user_id: int = None) -> 'AsyncApiKey':
         """
         [async] Get an ApiKey by name
 
@@ -2492,17 +2506,17 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             user_id (int, optional): specific user. privileges required.
 
         Returns:
-            ApiKey | None: returns the key if a key matches the given name, else None
+            AsyncApiKey | None: returns the key if a key matches the given name, else None
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     apikey = await client.get_apikey_by_name(name='test')
         """
-        return await ApiKey.get_apikey_by_name(self, name, user_id)
+        return await AsyncApiKey.get_apikey_by_name(self, name, user_id)
 
 
-    async def get_logs(self, **kwargs) -> List['Log']:
+    async def get_logs(self, **kwargs) -> List['AsyncLog']:
         """
         [async] Get a list of Logs
 
@@ -2518,29 +2532,29 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             activity_type (str): the user activity type.
 
         Returns:
-            List[Log]: a list of logs
+            List[AsyncLog]: a list of logs
 
         Example: 
             >>> from geobox.aio import AsyncGeoboxClient
             >>> async with AsyncGeoboxClient() as client:
             >>>     logs = await client.get_logs() 
         """ 
-        return await Log.get_logs(self, **kwargs)
+        return await AsyncLog.get_logs(self, **kwargs)
 
 
     async def get_api_usage(self, 
-                        resource: Union['User', 'ApiKey'], 
-                        scale: 'UsageScale',
-                        param: 'UsageParam',
-                        from_date: 'datetime' = None,
-                        to_date: 'datetime' = None,
-                        days_before_now: int = None,
-                        limit: int = None) -> List:
+        resource: Union['AsyncUser', 'AsyncApiKey'], 
+        scale: 'UsageScale',
+        param: 'UsageParam',
+        from_date: 'datetime' = None,
+        to_date: 'datetime' = None,
+        days_before_now: int = None,
+        limit: int = None) -> List:
         """
         [async] Get the api usage of a user
 
         Args:
-            resource (User | ApiKey): User or ApiKey object.
+            resource (AsyncUser | AsyncApiKey): User or ApiKey object.
             scale (UsageScale): the scale of the report.
             param (UsageParam): traffic or calls.
             from_date (datetime, optional): datetime object in this format: "%Y-%m-%dT%H:%M:%S". 
@@ -2564,21 +2578,21 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             ...                                         param=UsageParam.Calls, 
             ...                                         days_before_now=5)
         """
-        return await Usage.get_api_usage(self,
-                                    resource=resource, 
-                                    scale=scale,
-                                    param=param,
-                                    from_date=from_date,
-                                    to_date=to_date,
-                                    days_before_now=days_before_now,
-                                    limit=limit)
+        return await AsyncUsage.get_api_usage(self,
+            resource=resource, 
+            scale=scale,
+            param=param,
+            from_date=from_date,
+            to_date=to_date,
+            days_before_now=days_before_now,
+            limit=limit)
 
 
     async def get_process_usage(self, 
-                            user_id: int = None, 
-                            from_date: datetime = None, 
-                            to_date: datetime = None, 
-                            days_before_now: int = None) -> float:
+        user_id: int = None, 
+        from_date: datetime = None, 
+        to_date: datetime = None, 
+        days_before_now: int = None) -> float:
         """
         [async] Get process usage of a user in seconds
 
@@ -2599,11 +2613,11 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             >>> async with AsyncGeoboxClient() as client:
             >>>     process_usage = await client.get_process_usage(days_before_now=5)
         """
-        return await Usage.get_process_usage(self,
-                                        user_id=user_id,
-                                        from_date=from_date,
-                                        to_date=to_date,
-                                        days_before_now=days_before_now)
+        return await AsyncUsage.get_process_usage(self,
+            user_id=user_id,
+            from_date=from_date,
+            to_date=to_date,
+            days_before_now=days_before_now)
 
 
     async def get_usage_summary(self, user_id: int = None) -> Dict:
@@ -2621,7 +2635,7 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             >>> async with AsyncGeoboxClient() as client:
             >>>     usage_summary = await client.get_usage_summary()
         """
-        return await Usage.get_usage_summary(self, user_id=user_id)
+        return await AsyncUsage.get_usage_summary(self, user_id=user_id)
 
 
     async def update_usage(self, user_id: int = None) -> Dict:
@@ -2639,101 +2653,4 @@ class AsyncGeoboxClient(SyncGeoboxClient):
             >>> async with AsyncGeoboxClient() as client:
             >>>     await client.update_usage()
         """
-        return await Usage.update_usage(self, user_id=user_id)
-
-
-    async def raster_calculator(self,
-        variables: str,
-        expr: str,
-        output_raster_name: str,
-        match_raster_uuid: Optional[str] = None,
-        resample: AnalysisResampleMethod = AnalysisResampleMethod.bilinear,
-        out_dtype: AnalysisDataType = AnalysisDataType.float32,
-        dst_nodata: int = -9999,
-        user_id: Optional[int] = None) -> 'Task':
-        """
-        [async] Perform raster calculator operations on multiple raster datasets.
-
-        it allows you to perform mathematical operations on one or more raster datasets using NumPy expressions. 
-        Variables in the expression correspond to raster datasets specified in the variables dictionary.
-
-        Examples:
-            NDVI calculation: variables='{"NIR": "raster_uuid_1", "RED": "raster_uuid_2"}', expr="(NIR-RED)/(NIR+RED)"
-            Slope threshold: variables='{"SLOPE": "raster_uuid_1"}', expr="np.where(SLOPE>30,1,0)"
-            Multi-band operations: variables='{"IMG": ["raster_uuid_1", 2]}', expr="IMG*2"
-
-        Args:
-            variables (str): JSON string mapping variable names to raster specifications. Format: '{"NIR": "raster_uuid_1", "RED": "raster_uuid_2"}' or '{"IMG": ["raster_uuid_1", 2]}' for multi-band operations.
-            expr (str): Mathematical expression using NumPy syntax. Use variable names from the variables dict, e.g., '(NIR-RED)/(NIR+RED)' or 'where(SLOPE>30,1,0)' or 'where((dist_to_highway < 1000) & (slope < 10), 1, 0)' .Supported functions: np, sin, cos, tan, asin, acos, atan, sinh, cosh, tanh, exp, log, log10, sqrt, abs, floor, ceil, round, minimum, maximum, clip, where, isnan, isfinite, pi, e.
-            output_raster_name (str): Name for the output raster dataset.
-            match_raster_uuid (str, optional): Optional raster UUID to match the output grid and projection. If not provided, the first variable becomes the reference grid.
-            resample (CropResample, optional): Resampling method: 'near', 'bilinear', 'cubic', 'lanczos', etc. default: CropResample.near
-            out_dtype (AnalysisDataType, optional): Data type for the output raster (e.g., int16, float32). default: AnalysisDataType.float32
-            dst_nodata (int, optional): NoData value for the output raster. default = -9999
-            user_id (int, optional): specific user. priviledges required!
-
-        Returns:
-            Task: task instance of the process
-
-        Example:
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> async with AsyncGeoboxClient() as client:
-            >>>     task = await client.raster_calculator(api=client, variables={"NIR": "raster_uuid_1", "RED": "raster_uuid_2"},
-            ...         expr='where(SLOPE>30,1,0)',
-            ...         output_raster_name='test')
-        """
-        from .analysis import Analysis
-        return await Analysis.calculator(self,
-            variables=variables,
-            expr=expr,
-            output_raster_name=output_raster_name,
-            match_raster_uuid=match_raster_uuid,
-            resample=resample,
-            out_dtype=out_dtype,
-            dst_nodata=dst_nodata,
-            user_id=user_id)
-
-
-    async def create_constant_raster(self,
-        output_raster_name: str,
-        extent: str,
-        value : int,
-        pixel_size: int = 10,
-        dtype: AnalysisDataType = AnalysisDataType.float32,
-        nodata: int = -9999,
-        align_to: Optional[str] = None,
-        user_id: Optional[int] = None) -> 'Task':
-        """
-        [async] Create a raster filled with a constant value.
-
-        This endpoint creates a north-up GeoTIFF filled with a constant value. 
-        Only users with Publisher role or higher can perform this operation.
-
-        Args:
-            output_raster_name (str): Name for the output constant raster dataset.
-            extent (str): Extent as 'minX,minY,maxX,maxY' (e.g., '0,0,100,100').
-            value (int): Constant value to fill the raster with.
-            pixel_size (int, optional): Pixel size for the output raster (must be > 0). default: 10
-            dtype (AnalysisDataType, optoinal): Output data type. default: AnalysisDataType.float32
-            nodata (int, optional): NoData value for the raster. default: -9999
-            align_to (str, optional): Grid origin to snap to as 'x0,y0' (e.g., '0,0').
-            user_id (int, optional): specific user. priviledges required!
-
-        Returns:
-            Task: task instance of the process
-
-        Example:
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> async with AsyncGeoboxClient() as client:
-            >>>     task = await client.create_constant_raster(output_raster_name='test', extent='0,0,100,100', value=10)
-        """
-        from .analysis import Analysis
-        return await Analysis.constant(self,
-            output_raster_name=output_raster_name,
-            extent=extent,
-            value=value,
-            pixel_size=pixel_size,
-            dtype=dtype,
-            nodata=nodata,
-            align_to=align_to,
-            user_id=user_id)
+        return await AsyncUsage.update_usage(self, user_id=user_id)