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

geobox/aio/vectorlayer.py

@@ -2,25 +2,25 @@ from urllib.parse import urljoin
 from typing import List, Optional, TYPE_CHECKING, Dict, Union
 
 from .base import AsyncBase
-from .field import Field, FieldType
-from .feature import Feature
-from .task import Task
-from .version import VectorLayerVersion
+from .field import AsyncField, FieldType
+from .feature import AsyncFeature
+from .task import AsyncTask
+from .version import AsyncVectorLayerVersion
 from ..utils import clean_data
 from ..exception import NotFoundError
-from ..enums import LayerType, InputGeomType, FileOutputFormat, AnalysisDataType
+from ..enums import LayerType, InputGeomType, FileOutputFormat
 
 if TYPE_CHECKING:
     from .api import AsyncGeoboxClient
-    from .view import VectorLayerView
-    from .user import User
-    from .file import File
-    from .attachment import Attachment
-    from ..api import GeoboxClient as SyncGeoboxClient
-    from ..vectorlayer import VectorLayer as SyncVectorLayer
+    from .view import AsyncVectorLayerView
+    from .user import AsyncUser
+    from .file import AsyncFile
+    from .attachment import AsyncAttachment
+    from ..api import GeoboxClient
+    from ..vectorlayer import VectorLayer
 
 
-class VectorLayer(AsyncBase):
+class AsyncVectorLayer(AsyncBase):
     """
     A class representing a vector layer in Geobox.
     
@@ -31,10 +31,10 @@ class VectorLayer(AsyncBase):
     BASE_ENDPOINT = 'vectorLayers/'
 
     def __init__(self, 
-                 api: 'AsyncGeoboxClient', 
-                 uuid: str, 
-                 layer_type: LayerType, 
-                 data: Optional[Dict] = {}):
+        api: 'AsyncGeoboxClient', 
+        uuid: str, 
+        layer_type: LayerType, 
+        data: Optional[Dict] = {}):
         """
         Initialize a VectorLayer instance.
 
@@ -50,16 +50,16 @@ class VectorLayer(AsyncBase):
 
     def __repr__(self) -> str:
         """
-        Return a string representation of the VectorLayer object.
+        Return a string representation of the AsyncVectorLayer object.
 
         Returns:
-            str: A string representation of the VectorLayer object.
+            str: A string representation of the AsyncVectorLayer object.
         """
-        return f"VectorLayer(uuid={self.uuid}, name={self.name}, layer_type={self.layer_type})"
+        return f"AsyncVectorLayer(uuid={self.uuid}, name={self.name}, layer_type={self.layer_type})"
 
 
     @classmethod
-    async def get_vectors(cls, api: 'AsyncGeoboxClient', **kwargs) -> Union[List['VectorLayer'], int]:
+    async def get_vectors(cls, api: 'AsyncGeoboxClient', **kwargs) -> Union[List['AsyncVectorLayer'], int]:
         """
         [async] Get a list of vector layers with optional filtering and pagination.
         
@@ -80,30 +80,30 @@ class VectorLayer(AsyncBase):
             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 AsyncVectorLayer instances or the layers count if return_count is True.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.vectorlayer import VectorLayer
+            >>> from geobox.aio.vectorlayer import AsyncVectorLayer
             >>> async with AsyncGeoboxClient() as client:
-            >>>     layers = await VectorLayer.get_vectors(api=client, 
-            ...                                             include_settings=True, 
-            ...                                             skip=0, 
-            ...                                             limit=100, 
-            ...                                             return_count=False, 
-            ...                                             search="my_layer",
-            ...                                             search_fields="name, description",
-            ...                                             order_by="name",
-            ...                                             shared=True)
+            >>>     layers = await AsyncVectorLayer.get_vectors(api=client, 
+            ...         include_settings=True, 
+            ...         skip=0, 
+            ...         limit=100, 
+            ...         return_count=False, 
+            ...         search="my_layer",
+            ...         search_fields="name, description",
+            ...         order_by="name",
+            ...         shared=True)
             or  
             >>>     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)
+            ...         skip=0, 
+            ...         limit=100, 
+            ...         return_count=False, 
+            ...         search="my_layer",
+            ...         search_fields="name, description",
+            ...         order_by="name",
+            ...         shared=True)
         """
         params = {
             'f': 'json',
@@ -122,11 +122,11 @@ class VectorLayer(AsyncBase):
         return await super()._get_list(api=api, 
                                  endpoint=cls.BASE_ENDPOINT,
                                  params=params, 
-                                 factory_func=lambda api, item: VectorLayer(api, item['uuid'], LayerType(item['layer_type']), item))
+                                 factory_func=lambda api, item: AsyncVectorLayer(api, item['uuid'], LayerType(item['layer_type']), item))
 
 
     @classmethod
-    async def get_vector(cls, api: 'AsyncGeoboxClient', uuid: str, user_id: int = None) -> 'VectorLayer':
+    async def get_vector(cls, api: 'AsyncGeoboxClient', uuid: str, user_id: int = None) -> 'AsyncVectorLayer':
         """
         [async] Get a specific vector layer by its UUID.
         
@@ -136,16 +136,16 @@ class VectorLayer(AsyncBase):
             user_id (int, optional): Specific user. privileges required.
 
         Returns:
-            VectorLayer: The requested layer instance.
+            AsyncVectorLayer: The requested layer instance.
             
         Raises:
             NotFoundError: If the layer with the specified UUID is not found.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.vectorlayer import VectorLayer
+            >>> from geobox.aio.vectorlayer import AsyncVectorLayer
             >>> async with AsyncGeoboxClient() as client:
-            >>>     layer = await VectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     layer = await AsyncVectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
             or  
             >>>     layer = await client.get_vector(uuid="12345678-1234-5678-1234-567812345678")
         """
@@ -154,14 +154,14 @@ class VectorLayer(AsyncBase):
             'user_id': user_id
         }
         return await super()._get_detail(api=api,
-                                   endpoint=cls.BASE_ENDPOINT,
-                                   uuid=uuid, 
-                                   params=params, 
-                                   factory_func=lambda api, item: VectorLayer(api, item['uuid'], LayerType(item['layer_type']), item))
+            endpoint=cls.BASE_ENDPOINT,
+            uuid=uuid, 
+            params=params, 
+            factory_func=lambda api, item: AsyncVectorLayer(api, item['uuid'], LayerType(item['layer_type']), item))
 
 
     @classmethod
-    async def get_vector_by_name(cls, api: 'AsyncGeoboxClient', name: str, user_id: int = None) -> Union['VectorLayer', None]:
+    async def get_vector_by_name(cls, api: 'AsyncGeoboxClient', name: str, user_id: int = None) -> Union['AsyncVectorLayer', None]:
         """
         [async] Get a vector layer by name
 
@@ -171,13 +171,13 @@ class VectorLayer(AsyncBase):
             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
-            >>> from geobox.aio.vectorlayer import VectorLayer
+            >>> from geobox.aio.vectorlayer import AsyncVectorLayer
             >>> async with AsyncGeoboxClient() as client:
-            >>>     layer = await VectorLayer.get_vector_by_name(client, name='test')
+            >>>     layer = await AsyncVectorLayer.get_vector_by_name(client, name='test')
             or  
             >>>     layer = await client.get_vector_by_name(name='test')
         """
@@ -189,7 +189,7 @@ class VectorLayer(AsyncBase):
 
 
     @classmethod
-    async def get_vectors_by_ids(cls, api: 'AsyncGeoboxClient', ids: List[int], user_id: int = None, include_settings: bool = False) -> List['VectorLayer']:
+    async def get_vectors_by_ids(cls, api: 'AsyncGeoboxClient', ids: List[int], user_id: int = None, include_settings: bool = False) -> List['AsyncVectorLayer']:
         """
         [async] Get vector layers by their IDs.
 
@@ -200,13 +200,13 @@ class VectorLayer(AsyncBase):
             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 AsyncVectorLayer instances.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.vectorlayer import VectorLayer
+            >>> from geobox.aio.vectorlayer import AsyncVectorLayer
             >>> async with AsyncGeoboxClient() as client:
-            >>>     layers = await VectorLayer.get_vectors_by_ids(api=client, ids=[1, 2, 3])
+            >>>     layers = await AsyncVectorLayer.get_vectors_by_ids(api=client, ids=[1, 2, 3])
             or  
             >>>     layers = await client.get_vectors_by_ids(ids=[1, 2, 3])
         """
@@ -216,21 +216,21 @@ class VectorLayer(AsyncBase):
             'include_settings': include_settings
         }
         return await super()._get_list_by_ids(api=api, 
-                                        endpoint=f'{cls.BASE_ENDPOINT}get-layers/', 
-                                        params=params, 
-                                        factory_func=lambda api, item: VectorLayer(api, item['uuid'], LayerType(item['layer_type']), item))
+            endpoint=f'{cls.BASE_ENDPOINT}get-layers/', 
+            params=params, 
+            factory_func=lambda api, item: AsyncVectorLayer(api, item['uuid'], LayerType(item['layer_type']), item))
 
 
     @classmethod
     async def create_vector(cls, 
-                     api: 'AsyncGeoboxClient', 
-                     name: str, 
-                     layer_type: LayerType, 
-                     display_name: str = None,
-                     description: str = None, 
-                     has_z: bool = False, 
-                     temporary: bool = False,
-                     fields: List = None) -> 'VectorLayer':
+        api: 'AsyncGeoboxClient', 
+        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.
         
@@ -245,31 +245,31 @@ class VectorLayer(AsyncBase):
             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.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.vectorlayer import VectorLayer
+            >>> from geobox.aio.vectorlayer import AsyncVectorLayer
             >>> async with AsyncGeoboxClient() as client:
-            >>>     layer = await VectorLayer.create_vector(api=client, 
-            ...                                     name="my_layer", 
-            ...                                     layer_type=LayerType.Point,
-            ...                                     display_name="My Layer",
-            ...                                     description="This is a description of my layer",
-            ...                                     has_z=False,
-            ...                                     temporary=True,
-            ...                                     fields=[{"name": "my_field", "datatype": "FieldTypeString"}])
+            >>>     layer = await AsyncVectorLayer.create_vector(api=client, 
+            ...         name="my_layer", 
+            ...         layer_type=LayerType.Point,
+            ...         display_name="My Layer",
+            ...         description="This is a description of my layer",
+            ...         has_z=False,
+            ...         temporary=True,
+            ...         fields=[{"name": "my_field", "datatype": "FieldTypeString"}])
             or  
             >>>     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,
-            ...                                     temporary=True,
-            ...                                     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,
+            ...         temporary=True,
+            ...         fields=[{"name": "my_field", "datatype": "FieldTypeString"}])
         """
         data = {
             "name": name,
@@ -281,9 +281,9 @@ class VectorLayer(AsyncBase):
             "fields": fields
         }
         return await super()._create(api=api, 
-                               endpoint=cls.BASE_ENDPOINT,
-                               data=data, 
-                               factory_func=lambda api, item: VectorLayer(api, item['uuid'], layer_type, item))
+            endpoint=cls.BASE_ENDPOINT,
+            data=data, 
+            factory_func=lambda api, item: AsyncVectorLayer(api, item['uuid'], layer_type, item))
 
 
     async def update(self, **kwargs) -> Dict:
@@ -303,9 +303,9 @@ class VectorLayer(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.vectorlayer import VectorLayer
+            >>> from geobox.aio.vectorlayer import AsyncVectorLayer
             >>> async with AsyncGeoboxClient() as client:
-            >>>     layer = await VectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     layer = await AsyncVectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     await layer.update(name="new_name")
             >>>     await layer.update(display_name="new_display_name")
             >>>     await layer.update(description="new_description")
@@ -327,12 +327,12 @@ class VectorLayer(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.vectorlayer import VectorLayer
+            >>> from geobox.aio.vectorlayer import AsyncVectorLayer
             >>> async with AsyncGeoboxClient() as client:
-            >>>     layer = await VectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     layer = await AsyncVectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     await layer.delete()
         """
-        await super().delete(endpoint=self.endpoint)
+        await super()._delete(endpoint=self.endpoint)
 
 
     async def make_permanent(self) -> None:
@@ -344,9 +344,9 @@ class VectorLayer(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.vectorlayer import VectorLayer
+            >>> from geobox.aio.vectorlayer import AsyncVectorLayer
             >>> async with AsyncGeoboxClient() as client:
-            >>>     layer = await VectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     layer = await AsyncVectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     await layer.make_permanent()
         """
         endpoint = urljoin(self.endpoint, 'makePermanent/')
@@ -354,49 +354,49 @@ class VectorLayer(AsyncBase):
         self._update_properties(response)
 
 
-    async def share(self, users: List['User']) -> None:
+    async def share(self, users: List['AsyncUser']) -> None:
         """
         [async] Shares the layer with specified users.
 
         Args:
-            users (List[User]): The list of user objects to share the layer with.
+            users (List[AsyncUser]): The list of user objects to share the layer with.
 
         Returns:
             None
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.vectorlayer import VectorLayer
+            >>> from geobox.aio.vectorlayer import AsyncVectorLayer
             >>> async with AsyncGeoboxClient() as client:
-            >>>     layer = await VectorLayer.get_vector(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     layer = await AsyncVectorLayer.get_vector(client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     users = await client.search_users(search="John")
             >>>     await layer.share(users=users)
         """
         await super()._share(self.endpoint, users)
     
 
-    async def unshare(self, users: List['User']) -> None:
+    async def unshare(self, users: List['AsyncUser']) -> None:
         """
         [async] Unshares the layer with specified users.
 
         Args:
-            users (List[User]): The list of user objectss to unshare the layer with.
+            users (List[AsyncUser]): The list of user objectss to unshare the layer with.
 
         Returns:
             None
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.vectorlayer import VectorLayer
+            >>> from geobox.aio.vectorlayer import AsyncVectorLayer
             >>> async with AsyncGeoboxClient() as client:
-            >>>     layer = await VectorLayer.get_vector(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     layer = await AsyncVectorLayer.get_vector(client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     users = await client.search_users(search="John")
             >>>     await layer.unshare(users=users)
         """
         await super()._unshare(self.endpoint, users)
 
 
-    async def get_shared_users(self, search: str = None, skip: int = 0, limit: int = 10) -> List['User']:
+    async def get_shared_users(self, search: str = None, skip: int = 0, limit: int = 10) -> List['AsyncUser']:
         """
         [async] Retrieves the list of users the layer is shared with.
 
@@ -406,13 +406,13 @@ class VectorLayer(AsyncBase):
             limit (int, optional): The maximum number of users to retrieve.
 
         Returns:
-            List[User]: The list of shared users.
+            List[AsyncUser]: The list of shared users.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.vectorlayer import VectorLayer
+            >>> from geobox.aio.vectorlayer import AsyncVectorLayer
             >>> async with AsyncGeoboxClient() as client:
-            >>>     layer = await VectorLayer.get_vector(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     layer = await AsyncVectorLayer.get_vector(client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     await layer.get_shared_users(search='John', skip=0, limit=10)
         """
         params = {
@@ -423,7 +423,7 @@ class VectorLayer(AsyncBase):
         return await super()._get_shared_users(self.endpoint, params)
     
 
-    async def create_version(self, name: str, display_name: str = None, description: str = None) -> 'VectorLayerVersion':
+    async def create_version(self, name: str, display_name: str = None, description: str = None) -> 'AsyncVectorLayerVersion':
         """
         [async] Create a version from the layer
 
@@ -437,7 +437,7 @@ class VectorLayer(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.vectorlayer import VectorLayer
+            >>> from geobox.aio.vectorlayer import AsyncVectorLayer
             >>> async with AsyncGeoboxClient() as client:
             >>>     layer = await client.get_vector(uuid="12345678-1234-5678-1234-567812345678")
             >>>     version = await layer.create_version(name="my_version")
@@ -448,10 +448,10 @@ class VectorLayer(AsyncBase):
             "description": description
         }
         endpoint = urljoin(self.endpoint, 'versions')
-        return await super()._create(self.api, endpoint, data, factory_func=lambda api, item: VectorLayerVersion(api, item['uuid'], item))
+        return await super()._create(self.api, endpoint, data, factory_func=lambda api, item: AsyncVectorLayerVersion(api, item['uuid'], item))
 
 
-    async def get_versions(self, **kwargs) -> List['VectorLayerVersion']:
+    async def get_versions(self, **kwargs) -> List['AsyncVectorLayerVersion']:
         """
         [async] Get list of versions of the current vector layer object with optional filtering and pagination.
 
@@ -467,18 +467,17 @@ class VectorLayer(AsyncBase):
             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
-            >>> from geobox.aio.vectorlayer import VectorLayer
             >>> async with AsyncGeoboxClient() as client:
             >>>     layer = await client.get_vector(uuid="12345678-1234-5678-1234-567812345678")
             >>>     versions = await layer.get_versions()
             or  
             >>>     versions = await layer.get_versions()
         """
-        return await VectorLayerVersion.get_versions(self.api, layer_id=self.id, **kwargs)
+        return await AsyncVectorLayerVersion.get_versions(self.api, layer_id=self.id, **kwargs)
 
 
     @property    
@@ -491,9 +490,9 @@ class VectorLayer(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.vectorlayer import VectorLayer
+            >>> from geobox.aio.vectorlayer import AsyncVectorLayer
             >>> async with AsyncGeoboxClient() as client:
-            >>>     layer = await VectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     layer = await AsyncVectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     layer.wfs
         """
         if self.api.access_token:
@@ -502,27 +501,27 @@ class VectorLayer(AsyncBase):
             return f'{self.api.base_url}{self.endpoint}apikey:{self.api.apikey}/wfs/'
 
 
-    async def get_fields(self) -> List['Field']:
+    async def get_fields(self) -> List['AsyncField']:
         """
         [async] Get all fields in the layer.
         
         Returns:
-            List[Field]: A list of Field instances representing the layer's fields.
+            List[AsyncField]: A list of Field instances representing the layer's fields.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.vectorlayer import VectorLayer
+            >>> from geobox.aio.vectorlayer import AsyncVectorLayer
             >>> async with AsyncGeoboxClient() as client:
-            >>>     layer = await VectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     layer = await AsyncVectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     fields = await layer.get_fields()
         """
         endpoint = urljoin(self.endpoint, 'fields/')
         return await super()._get_list(api=self.api, 
-                            endpoint=endpoint,
-                            factory_func=lambda api, item: Field(layer=self, data_type=FieldType(item['datatype']), field_id=item['id'], data=item))
+            endpoint=endpoint,
+            factory_func=lambda api, item: AsyncField(layer=self, data_type=FieldType(item['datatype']), field_id=item['id'], data=item))
 
 
-    async def get_field(self, field_id: int) -> 'Field':
+    async def get_field(self, field_id: int) -> 'AsyncField':
         """
         [async] Get a specific field by its ID.
         
@@ -537,9 +536,9 @@ class VectorLayer(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.vectorlayer import VectorLayer
+            >>> from geobox.aio.vectorlayer import AsyncVectorLayer
             >>> async with AsyncGeoboxClient() as client:
-            >>>     layer = await VectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     layer = await AsyncVectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     field = await layer.get_field(field_id=1)
         """        
         field = next((f for f in await self.get_fields() if f.id == field_id), None)
@@ -549,7 +548,7 @@ class VectorLayer(AsyncBase):
         return field
 
 
-    async def get_field_by_name(self, name: str) -> 'Field':
+    async def get_field_by_name(self, name: str) -> 'AsyncField':
         """
         [async] Get a specific field by its name.
         
@@ -557,16 +556,16 @@ class VectorLayer(AsyncBase):
             name (str): The name of the field to retrieve.
 
         Returns:
-            Field: The requested field instance.
+            AsyncField: The requested field instance.
             
         Raises:
             NotFoundError: If the field with the specified name is not found. 
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.vectorlayer import VectorLayer
+            >>> from geobox.aio.vectorlayer import AsyncVectorLayer
             >>> async with AsyncGeoboxClient() as client:
-            >>>     layer = await VectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     layer = await AsyncVectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     field = await layer.get_field_by_name(name='test')
         """        
         field = next((f for f in await self.get_fields() if f.name == name), None)
@@ -576,7 +575,7 @@ class VectorLayer(AsyncBase):
         return field
 
 
-    async def add_field(self, name: str, data_type: 'FieldType', data: Dict = {}) -> 'Field':
+    async def add_field(self, name: str, data_type: 'FieldType', data: Dict = {}) -> 'AsyncField':
         """
         [async] Add a new field to the layer.
         
@@ -586,30 +585,30 @@ class VectorLayer(AsyncBase):
             data (Dict): Additional field properties (display_name, description, etc.).
             
         Returns:
-            Field: The newly created field instance.
+            AsyncField: The newly created field instance.
             
         Raises:
             ValidationError: If the field data is invalid.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.vectorlayer import VectorLayer
+            >>> from geobox.aio.vectorlayer import AsyncVectorLayer
             >>> async with AsyncGeoboxClient() as client:
-            >>>     layer = await VectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     layer = await AsyncVectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     field = await layer.add_field(name="new_field", data_type=FieldType.String)
         """
-        return await Field.create_field(self.api, layer=self, name=name, data_type=data_type, data=data)
+        return await AsyncField.create_field(self.api, layer=self, name=name, data_type=data_type, data=data)
 
 
     async def calculate_field(self, 
-                        target_field: str, 
-                        expression: str, 
-                        q: str = None, 
-                        bbox: List = None, 
-                        bbox_srid: int = None, 
-                        feature_ids: List = None, 
-                        run_async: bool = True, 
-                        user_id: int = None) -> Union['Task', Dict]:
+        target_field: str, 
+        expression: str, 
+        q: str = None, 
+        bbox: List = None, 
+        bbox_srid: int = None, 
+        feature_ids: List = None, 
+        run_async: bool = True, 
+        user_id: int = None) -> Union['AsyncTask', Dict]:
         """
         [async] Calculate values for a field based on an expression.
         
@@ -624,20 +623,20 @@ class VectorLayer(AsyncBase):
             user_id (int, optional): Specific user. privileges required.
             
         Returns:
-            Task | Dict: The task instance of the calculation operation or the api response if the run_async=False.
+            AsyncTask | Dict: The task instance of the calculation operation or the api response if the run_async=False.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.vectorlayer import VectorLayer
+            >>> from geobox.aio.vectorlayer import AsyncVectorLayer
             >>> async with AsyncGeoboxClient() as client:
-            >>>     layer = await VectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     layer = await AsyncVectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     task = await layer.calculate_field(target_field="target_field", 
-            ...                                         expression="expression", 
-            ...                                         q="name like 'my_layer'", 
-            ...                                         bbox=[10, 20, 30, 40], 
-            ...                                         bbox_srid=3857, 
-            ...                                         feature_ids=[1, 2, 3], 
-            ...                                         run_async=True)
+            ...        expression="expression", 
+            ...        q="name like 'my_layer'", 
+            ...        bbox=[10, 20, 30, 40], 
+            ...        bbox_srid=3857, 
+            ...        feature_ids=[1, 2, 3], 
+            ...        run_async=True)
         """
         data = clean_data({
             "target_field": target_field,
@@ -653,13 +652,13 @@ class VectorLayer(AsyncBase):
         endpoint = urljoin(self.endpoint, 'calculateField/')
         response = await self.api.post(endpoint, data, is_json=False)
         if run_async:
-            task = await Task.get_task(self.api, response.get('task_id'))
+            task = await AsyncTask.get_task(self.api, response.get('task_id'))
             return task
 
         return response
 
 
-    async def get_features(self, **kwargs) -> Union[List['Feature'], int]:
+    async def get_features(self, **kwargs) -> Union[List['AsyncFeature'], int]:
         """
         [async] Get features from the layer with optional filtering and pagination.
         
@@ -686,17 +685,18 @@ class VectorLayer(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.vectorlayer import VectorLayer
+            >>> from geobox.aio.vectorlayer import AsyncVectorLayer
             >>> async with AsyncGeoboxClient() as client:
-            >>>     layer = await VectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
-            >>>     features = await layer.get_features(quant_factor=1000000, 
-            ...                                         skip=0, 
-            ...                                         limit=100, 
-            ...                                         skip_geometry=False, 
-            ...                                         return_count=False, 
-            ...                                         select_fields="fclass, osm_id", 
-            ...                                         out_srid=3857, 
-            ...                                         bbox_srid=3857)
+            >>>     layer = await AsyncVectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     features = await layer.get_features(
+            ...         quant_factor=1000000, 
+            ...         skip=0, 
+            ...         limit=100, 
+            ...         skip_geometry=False, 
+            ...         return_count=False, 
+            ...         select_fields="fclass, osm_id", 
+            ...         out_srid=3857, 
+            ...         bbox_srid=3857)
         """
         params = {
             'f': 'json',
@@ -719,13 +719,13 @@ class VectorLayer(AsyncBase):
         }
 
         return await super()._get_list(api=self.api,
-                            endpoint=f'{self.endpoint}features/',
-                            params=params,
-                            factory_func=lambda api, item, srid: Feature(self, srid, item),
-                            geojson=True)
+            endpoint=f'{self.endpoint}features/',
+            params=params,
+            factory_func=lambda api, item, srid: AsyncFeature(self, srid, item),
+            geojson=True)
 
 
-    async def get_feature(self, feature_id: int, out_srid: int = Feature.BASE_SRID) -> 'Feature':
+    async def get_feature(self, feature_id: int, out_srid: int = AsyncFeature.BASE_SRID) -> 'AsyncFeature':
         """
         [async] Get a specific feature by its ID.
         
@@ -741,21 +741,21 @@ class VectorLayer(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.vectorlayer import VectorLayer
+            >>> from geobox.aio.vectorlayer import AsyncVectorLayer
             >>> async with AsyncGeoboxClient() as client:
-            >>>     layer = await VectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     layer = await AsyncVectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     feature = await layer.get_feature(feature_id=1, out_srid=4326)
         """
         endpoint = f"{self.endpoint}features/{feature_id}"
         response = await self.api.get(endpoint)
-        feature = Feature(self, data=response)
-        if out_srid != Feature.BASE_SRID:
+        feature = AsyncFeature(self, data=response)
+        if out_srid != AsyncFeature.BASE_SRID:
             feature.transform(out_srid)
 
         return feature
 
 
-    async def create_feature(self, geojson: Dict)-> 'Feature':
+    async def create_feature(self, geojson: Dict)-> 'AsyncFeature':
         """
         [async] Create a new feature in the layer.
         
@@ -770,9 +770,9 @@ class VectorLayer(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.vectorlayer import VectorLayer
+            >>> from geobox.aio.vectorlayer import AsyncVectorLayer
             >>> async with AsyncGeoboxClient() as client:
-            >>>     layer = await VectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     layer = await AsyncVectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     geojson = {
             ...        "type": "Feature",
             ...        "geometry": {"type": "Point", "coordinates": [10, 20]},
@@ -780,11 +780,16 @@ class VectorLayer(AsyncBase):
             ...     }
             >>>     feature = await layer.create_feature(geojson=geojson)
         """
-        return await Feature.create_feature(self, geojson)
+        return await AsyncFeature.create_feature(self, geojson)
 
 
-    async def delete_features(self, q: str = None, bbox: str = None, bbox_srid: int = None, feature_ids: List[int] = None, 
-                        run_async: bool = True, user_id: int = None) -> Union['Task', Dict]:
+    async def delete_features(self, 
+        q: str = None, 
+        bbox: str = None, 
+        bbox_srid: int = None, 
+        feature_ids: List[int] = None, 
+        run_async: bool = True, 
+        user_id: int = None) -> Union['AsyncTask', Dict]:
         """
         [async] Delete features from the layer based on specified criteria.
         
@@ -797,21 +802,21 @@ class VectorLayer(AsyncBase):
             user_id (int, optional): Specific user. privileges required.
             
         Returns:
-            Task | Dict: The task instance of the deletion operation or the api response if run_async=False.
+            AsyncTask | Dict: The task instance of the deletion operation or the api response if run_async=False.
             
         Raises:
             ValidationError: If the deletion parameters are invalid.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.vectorlayer import VectorLayer
+            >>> from geobox.aio.vectorlayer import AsyncVectorLayer
             >>> async with AsyncGeoboxClient() as client:
-            >>>     layer = await VectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     layer = await AsyncVectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     await layer.delete_features(q="name like 'my_layer'", 
-            ...                                 bbox='10, 20, 30, 40',
-            ...                                 bbox_srid=3857, 
-            ...                                 feature_ids='1, 2, 3', 
-            ...                                 run_async=True)
+            ...         bbox='10, 20, 30, 40',
+            ...         bbox_srid=3857, 
+            ...         feature_ids='1, 2, 3', 
+            ...         run_async=True)
         """
         data = clean_data({
             "q": q,
@@ -825,22 +830,22 @@ class VectorLayer(AsyncBase):
         endpoint = urljoin(self.endpoint, 'deleteFeatures/')
         response = await self.api.post(endpoint, data, is_json=False)
         if run_async:
-            task = await Task.get_task(self.api, response.get('task_id'))
+            task = await AsyncTask.get_task(self.api, response.get('task_id'))
             return task
 
         return response
 
 
     async def import_features(self, 
-                            file: 'File', 
-                            input_geom_type: 'InputGeomType' = None, 
-                            input_layer_name: str = None, 
-                            input_dataset: str = None, 
-                            user_id: int = None, 
-                            input_srid: int = None, 
-                            file_encoding: str = "utf-8", 
-                            replace_domain_codes_by_values: bool = False, 
-                            report_errors: bool = True) -> 'Task':
+        file: 'AsyncFile', 
+        input_geom_type: 'InputGeomType' = None, 
+        input_layer_name: str = None, 
+        input_dataset: str = None, 
+        user_id: int = None, 
+        input_srid: int = None, 
+        file_encoding: str = "utf-8", 
+        replace_domain_codes_by_values: bool = False, 
+        report_errors: bool = True) -> 'AsyncTask':
         """
         [async] Import features from a file into the layer.
         
@@ -856,25 +861,25 @@ class VectorLayer(AsyncBase):
             report_errors (bool, optional): Whether to report import errors.
             
         Returns:
-            Task: The task instance of the import operation.
+            AsyncTask: The task instance of the import operation.
             
         Raises:
             ValidationError: If the import parameters are invalid.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.vectorlayer import VectorLayer
+            >>> from geobox.aio.vectorlayer import AsyncVectorLayer
             >>> async with AsyncGeoboxClient() as client:
-            >>>     layer = await VectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     layer = await AsyncVectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     file = await client.get_file(uuid="12345678-1234-5678-1234-567812345678")
             >>>     task = await layer.import_features(file=file, 
-            ...                             input_geom_type=InputGeomType.POINT,
-            ...                             input_layer_name="my_layer",
-            ...                             input_dataset="my_dataset",
-            ...                             input_srid=3857,
-            ...                             file_encoding="utf-8",
-            ...                             replace_domain_codes_by_values=False, 
-            ...                             report_errors=True)
+            ...         input_geom_type=InputGeomType.POINT,
+            ...         input_layer_name="my_layer",
+            ...         input_dataset="my_dataset",
+            ...         input_srid=3857,
+            ...         file_encoding="utf-8",
+            ...         replace_domain_codes_by_values=False, 
+            ...         report_errors=True)
         """
         data = clean_data({
             "file_uuid": file.uuid,
@@ -890,21 +895,21 @@ class VectorLayer(AsyncBase):
 
         endpoint = urljoin(self.endpoint, 'import/')
         response = await self.api.post(endpoint, data, is_json=False)
-        task = await Task.get_task(self.api, response.get('task_id'))
+        task = await AsyncTask.get_task(self.api, response.get('task_id'))
         return task
 
 
     async def export_features(self, 
-                            out_filename: str, 
-                            out_format: 'FileOutputFormat', 
-                            replace_domain_codes_by_values: bool = False, 
-                            run_async: bool = True, 
-                            bbox: List[float] = None, 
-                            out_srid: int = None, 
-                            zipped: bool = True, 
-                            feature_ids: List[int] = None, 
-                            bbox_srid: int = None, 
-                            q: str = None, fields: List[str] = None) -> Union['Task', Dict]:
+        out_filename: str, 
+        out_format: 'FileOutputFormat', 
+        replace_domain_codes_by_values: bool = False, 
+        run_async: bool = True, 
+        bbox: List[float] = None, 
+        out_srid: int = None, 
+        zipped: bool = True, 
+        feature_ids: List[int] = None, 
+        bbox_srid: int = None, 
+        q: str = None, fields: List[str] = None) -> Union['AsyncTask', Dict]:
         """
         [async] Export features from the layer to a file.
         
@@ -922,24 +927,24 @@ class VectorLayer(AsyncBase):
             fields (List[str], optional): List of fields to include in the export.
             
         Returns:
-            Task | Dict: The task instance of the export operation or the api response if run_async=False.
+            AsyncTask | Dict: The task instance of the export operation or the api response if run_async=False.
             
         Raises:
             ValidationError: If the export parameters are invalid.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.vectorlayer import VectorLayer
+            >>> from geobox.aio.vectorlayer import AsyncVectorLayer
             >>> async with AsyncGeoboxClient() as client:
-            >>>     layer = await VectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     layer = await AsyncVectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     task = await layer.export_features(out_filename="output.shp", 
-            ...                             out_format="shp",
-            ...                             replace_domain_codes_by_values=False, 
-            ...                             run_async=True, 
-            ...                             bbox=[10, 20, 30, 40], 
-            ...                             out_srid=3857, 
-            ...                             zipped=True, 
-            ...                             feature_ids=[1, 2, 3])
+            ...         out_format="shp",
+            ...         replace_domain_codes_by_values=False, 
+            ...         run_async=True, 
+            ...         bbox=[10, 20, 30, 40], 
+            ...         out_srid=3857, 
+            ...         zipped=True, 
+            ...         feature_ids=[1, 2, 3])
         """
         data = clean_data({
             "replace_domain_codes_by_values": replace_domain_codes_by_values,
@@ -958,14 +963,19 @@ class VectorLayer(AsyncBase):
         endpoint = urljoin(self.endpoint, 'export/')
         response = await self.api.post(endpoint, data, is_json=False)
         if run_async:
-            task = await Task.get_task(self.api, response.get('task_id'))
+            task = await AsyncTask.get_task(self.api, response.get('task_id'))
             return task
 
         return response
 
 
-    async def create_view(self, name: str, display_name: str = None, description: str = None, 
-                    view_filter: str = None, view_extent: Dict = None, view_cols: str = None) -> 'VectorLayerView':
+    async def create_view(self, 
+        name: str, 
+        display_name: str = None,
+        description: str = None, 
+        view_filter: str = None, 
+        view_extent: Dict = None, 
+        view_cols: str = None) -> 'AsyncVectorLayerView':
         """
         [async] Create a view of the vector layer.
 
@@ -978,24 +988,24 @@ class VectorLayer(AsyncBase):
             view_cols (str, optional): The columns to include in the view.
 
         Returns:
-            VectorLayerView: The created view instance.
+            AsyncVectorLayerView: The created view instance.
 
         Raises:
             ValidationError: If the view parameters are invalid.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.vectorlayer import VectorLayer
+            >>> from geobox.aio.vectorlayer import AsyncVectorLayer
             >>> async with AsyncGeoboxClient() as client:
-            >>>     layer = await VectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     layer = await AsyncVectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     view = await layer.create_view(name="my_view", 
-            ...                             display_name="My View", 
-            ...                             description="This is a view of my layer", 
-            ...                             view_filter="province_name = 'Tehran'", 
-            ...                             view_extent=[10, 20, 30, 40], 
-            ...                             view_cols="[ALL]")
+            ...         display_name="My View", 
+            ...         description="This is a view of my layer", 
+            ...         view_filter="province_name = 'Tehran'", 
+            ...         view_extent=[10, 20, 30, 40], 
+            ...         view_cols="[ALL]")
         """
-        from .view import VectorLayerView
+        from .view import AsyncVectorLayerView
 
         data = {
             "name": name,
@@ -1007,9 +1017,9 @@ class VectorLayer(AsyncBase):
         }
 
         return await super()._create(api=self.api,
-                            endpoint=f'{self.endpoint}views/',
-                            data=data,
-                            factory_func=lambda api, item: VectorLayerView(api, item['uuid'], self.layer_type, item))
+            endpoint=f'{self.endpoint}views/',
+            data=data,
+            factory_func=lambda api, item: AsyncVectorLayerView(api, item['uuid'], self.layer_type, item))
 
 
     def get_tile_pbf_url(self, x: int = '{x}', y: int = '{y}', z: int = '{z}') -> str:
@@ -1026,9 +1036,9 @@ class VectorLayer(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.vectorlayer import VectorLayer
+            >>> from geobox.aio.vectorlayer import AsyncVectorLayer
             >>> async with AsyncGeoboxClient() as client:
-            >>>     layer = await VectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     layer = await AsyncVectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     tile = layer.get_tile(x=10, y=20, z=1)
         """
         endpoint = f'{self.api.base_url}{self.endpoint}tiles/{z}/{x}/{y}.pbf'
@@ -1048,9 +1058,9 @@ class VectorLayer(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.vectorlayer import VectorLayer
+            >>> from geobox.aio.vectorlayer import AsyncVectorLayer
             >>> async with AsyncGeoboxClient() as client:
-            >>>     layer = await VectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     layer = await AsyncVectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     tile_json = await layer.get_tile_json()
         """
         endpoint = urljoin(self.endpoint, 'tilejson.json') 
@@ -1067,9 +1077,9 @@ class VectorLayer(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.vectorlayer import VectorLayer
+            >>> from geobox.aio.vectorlayer import AsyncVectorLayer
             >>> async with AsyncGeoboxClient() as client:
-            >>>     layer = await VectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     layer = await AsyncVectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     setting = await layer.setting
         """
         return await super()._get_settings(endpoint=self.endpoint)
@@ -1086,7 +1096,6 @@ class VectorLayer(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.vectorlayer import VectorLayer
             >>> async with AsyncGeoboxClient() as client:
             >>>     layer1 = await client.get_vector(uuid="12345678-1234-5678-1234-567812345678")
             >>>     layer2 = await client.get_vector(uuid="12345678-1234-5678-1234-567812345678")
@@ -1124,24 +1133,24 @@ class VectorLayer(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.vectorlayer import VectorLayer
+            >>> from geobox.aio.vectorlayer import AsyncVectorLayer
             >>> async with AsyncGeoboxClient() as client:
-            >>>     layer = await VectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     layer = await AsyncVectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     await layer.set_settings(title_field="name",
-            ...                          domain_display_type="Value",
-            ...                          allow_export=True,
-            ...                          editable=True,
-            ...                          edit_geometry=True,
-            ...                          editable_attributes="[ALL]",
-            ...                          allow_insert=True,
-            ...                          allow_delete=True,
-            ...                          min_zoom=0,
-            ...                          max_zoom=24,
-            ...                          max_features=65536,
-            ...                          filter_features=True,
-            ...                          fields=["id"],
-            ...                          use_cache=True,
-            ...                          cache_until_zoom=17)
+            ...         domain_display_type="Value",
+            ...         allow_export=True,
+            ...         editable=True,
+            ...         edit_geometry=True,
+            ...         editable_attributes="[ALL]",
+            ...         allow_insert=True,
+            ...         allow_delete=True,
+            ...         min_zoom=0,
+            ...         max_zoom=24,
+            ...         max_features=65536,
+            ...         filter_features=True,
+            ...         fields=["id"],
+            ...         use_cache=True,
+            ...         cache_until_zoom=17)
         """
         general_settings = {'title_field', 'domain_display_type', 'allow_export'}
         edit_settings = {'editable', 'edit_geometry', 'editable_attributes', 'allow_insert', 'allow_delete'}
@@ -1160,7 +1169,7 @@ class VectorLayer(AsyncBase):
         return await super()._set_settings(endpoint=self.endpoint, data=settings)
 
 
-    async def seed_cache(self, from_zoom: int = None, to_zoom: int = None, ignore_cache: bool = False, workers: int = 1, user_id: int = None) -> List['Task']:
+    async def seed_cache(self, from_zoom: int = None, to_zoom: int = None, ignore_cache: bool = False, workers: int = 1, user_id: int = None) -> List['AsyncTask']:
         """
         [async] Seed the cache for the layer.
         
@@ -1172,13 +1181,13 @@ class VectorLayer(AsyncBase):
             user_id (int, optional): Specific user. privileges required.
 
         Returns:
-            List[Task]: The task instance of the cache seeding operation.
+            List[AsyncTask]: The task instance of the cache seeding operation.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.vectorlayer import VectorLayer
+            >>> from geobox.aio.vectorlayer import AsyncVectorLayer
             >>> async with AsyncGeoboxClient() as client:
-            >>>     layer = await VectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     layer = await AsyncVectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     task = await layer.seed_cache(from_zoom=0, to_zoom=10, ignore_cache=False, workers=1)
         """
         data = {
@@ -1200,9 +1209,9 @@ class VectorLayer(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.vectorlayer import VectorLayer
+            >>> from geobox.aio.vectorlayer import AsyncVectorLayer
             >>> async with AsyncGeoboxClient() as client:
-            >>>     layer = await VectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     layer = await AsyncVectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     await layer.clear_cache()
         """
         await super()._clear_cache(endpoint=self.endpoint)
@@ -1218,9 +1227,9 @@ class VectorLayer(AsyncBase):
             
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.vectorlayer import VectorLayer
+            >>> from geobox.aio.vectorlayer import AsyncVectorLayer
             >>> async with AsyncGeoboxClient() as client:
-            >>>     layer = await VectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     layer = await AsyncVectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     await layer.cache_size
         """
         return await super()._cache_size(endpoint=self.endpoint)
@@ -1235,9 +1244,9 @@ class VectorLayer(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.vectorlayer import VectorLayer
+            >>> from geobox.aio.vectorlayer import AsyncVectorLayer
             >>> async with AsyncGeoboxClient() as client:
-            >>>     layer = await VectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     layer = await AsyncVectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     await layer.update_stats()
         """
         endpoint = urljoin(self.endpoint, 'updateStats/')
@@ -1253,16 +1262,16 @@ class VectorLayer(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.vectorlayer import VectorLayer
+            >>> from geobox.aio.vectorlayer import AsyncVectorLayer
             >>> async with AsyncGeoboxClient() as client:
-            >>>     layer = await VectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     layer = await AsyncVectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     await layer.prune_edited_areas()
         """
         endpoint = urljoin(self.endpoint, 'prune/')
         return await self.api.post(endpoint)
     
 
-    async def get_attachments(self, **kwargs) -> List['Attachment']:
+    async def get_attachments(self, **kwargs) -> List['AsyncAttachment']:
         """
         [async] Get the resouces attachments
 
@@ -1275,31 +1284,31 @@ class VectorLayer(AsyncBase):
             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
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.vectorlayer import VectorLayer
+            >>> from geobox.aio.vectorlayer import AsyncVectorLayer
             >>> async with AsyncGeoboxClient() as client:
-            >>>     layer = await VectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     layer = await AsyncVectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     await layer.get_attachments()
         """
-        from .attachment import Attachment
+        from .attachment import AsyncAttachment
 
-        return await Attachment.get_attachments(self.api, resource=self, **kwargs)
+        return await AsyncAttachment.get_attachments(self.api, resource=self, **kwargs)
     
     
     async def create_attachment(self, 
-                            name: str, 
-                            loc_x: int,
-                            loc_y: int,
-                            file: 'File',
-                            feature: 'Feature' = None,
-                            display_name: str = None, 
-                            description: str = None) -> 'Attachment':
+        name: str, 
+        loc_x: int,
+        loc_y: int,
+        file: 'AsyncFile',
+        feature: 'AsyncFeature' = None,
+        display_name: str = None, 
+        description: str = None) -> 'AsyncAttachment':
         """
         [async] Create a new Attachment.
 
@@ -1313,158 +1322,51 @@ class VectorLayer(AsyncBase):
             description (str, optional): The description of the scene.
 
         Returns:
-            Attachment: The newly created Attachment instance.
+            AsyncAttachment: The newly created Attachment instance.
 
         Raises:
             ValidationError: If the Attachment data is invalid.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.vectorlayer import VectorLayer
+            >>> from geobox.aio.vectorlayer import AsyncVectorLayer
             >>> async with AsyncGeoboxClient() as client:
-            >>>     layer = await VectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     layer = await AsyncVectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     file = await client.get_file(uuid="12345678-1234-5678-1234-567812345678")
             >>>     await layer.create_attachment(name='test', loc_x=10, loc_y=10, file=file)
         """
-        from .attachment import Attachment
-
-        return await Attachment.create_attachment(self.api,
-                                            name=name,
-                                            loc_x=loc_x,
-                                            loc_y=loc_y,
-                                            resource=self,
-                                            file=file,
-                                            feature=feature,
-                                            display_name=display_name,
-                                            description=description)
+        from .attachment import AsyncAttachment
+
+        return await AsyncAttachment.create_attachment(self.api,
+            name=name,
+            loc_x=loc_x,
+            loc_y=loc_y,
+            resource=self,
+            file=file,
+            feature=feature,
+            display_name=display_name,
+            description=description)
     
 
-    def to_sync(self, sync_client: 'SyncGeoboxClient') -> 'SyncVectorLayer':
+    def to_sync(self, sync_client: 'GeoboxClient') -> 'VectorLayer':
         """
         Switch to sync version of the vector layer instance to have access to the sync methods
 
         Args:
-            sync_client (SyncGeoboxClient): The sync version of the GeoboxClient instance for making requests.
+            sync_client (GeoboxClient): The sync version of the GeoboxClient instance for making requests.
 
         Returns:
-            geobox.vectorlayer.VectorLayer: the sync instance of the vector layer.
+            VectorLayer: the sync instance of the vector layer.
 
         Example:
             >>> from geobox import Geoboxclient
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.vectorlayer import VectorLayer
+            >>> from geobox.aio.vectorlayer import AsyncVectorLayer
             >>> client = GeoboxClient()
             >>> async with AsyncGeoboxClient() as async_client:
-            >>>     layer = await VectorLayer.get_vector(async_client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     layer = await AsyncVectorLayer.get_vector(async_client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     sync_layer = layer.to_sync(client)
         """
-        from ..vectorlayer import VectorLayer as SyncVectorLayer
-
-        return SyncVectorLayer(api=sync_client, uuid=self.uuid, layer_type=self.layer_type, data=self.data)
-
-
-
-
-    async def rasterize(self, 
-        output_raster_name: str,
-        pixel_size: int = 10,
-        nodata: Optional[int] = -9999,
-        data_type: Optional[AnalysisDataType] = AnalysisDataType.int16,
-        burn_value: Optional[int] = 1,
-        burn_attribute: Optional[str] = None,
-        user_id: Optional[int] = None) -> 'Task':
-        """
-        [async] Rasterize a vector layer.
-
-        This method converts a vector layer (or view) to a raster dataset using the specified parameters. 
-        You can control the output raster's name, pixel size, data type, nodata value, and the value to burn (either a constant or from an attribute field). 
-        Only users with Publisher role or higher can perform this operation.
-
-        Args:
-            output_raster_name (str): Name for the output raster dataset
-            pixel_size (int, optional): Pixel size for the output raster (must be > 0). default: 10
-            nodata (int, optional): NoData value to use in the output raster. default: -9999
-            data_type (AnalysisDataType, optional): Data type for the output raster (e.g., int16, float32). default: AnalysisDataType.int16
-            burn_value (int, optional): Value to burn into the raster for all features (if burn_attribute is not set). default: 1
-            burn_attribute (str, optional): Name of the attribute field to use for burning values into the raster
-            user_id (int, optional): specific user. priviledges required!
-
-        Returns:
-            Task: task instance of the process
+        from ..vectorlayer import VectorLayer
 
-        Example:
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> async with AsyncGeoboxClient() as client:
-            >>>     vector = await client.get_vector(uuid="12345678-1234-5678-1234-567812345678")
-            >>>     task = await vector.rasterize(output_raster_name='test')
-        """
-        from .analysis import Analysis
-        return await Analysis.rasterize(self.api,
-                                    self,
-                                    output_raster_name=output_raster_name,
-                                    burn_attribute=burn_attribute,
-                                    pixel_size=pixel_size,
-                                    nodata=nodata,
-                                    data_type=data_type,
-                                    burn_value=burn_value,
-                                    user_id=user_id)
-
-
-    async def idw_interpolation(self,
-        output_raster_name: str,
-        z_field: Field,
-        match_raster_uuid: Optional[str] = None,
-        pixel_size: int = 10,
-        extent: Optional[str] = None,
-        power: float = 2.0,
-        smoothing: float = 0.0,
-        max_points: int = 16,
-        radius: int = 1000,
-        nodata: int = -9999,
-        out_dtype: AnalysisDataType = AnalysisDataType.float32,
-        user_id: Optional[int] = None) -> 'Task':
-        """
-        [async] Create an IDW (Inverse Distance Weighting) interpolation raster from point data.
-
-        it creates a raster using IDW interpolation from point data in a vector layer. 
-        Only users with Publisher role or higher can perform this operation.
-
-        Args:
-            output_raster_name (str): Name for the output IDW raster dataset.
-            z_field (Field): the field containing the values to interpolate.
-            match_raster_uuid (str, optional): UUID of reference raster to match resolution/extent.
-            pixel_size (int, optional): Pixel size for the output raster. default: 10
-            extent (str, optional): Extent as 'minX,minY,maxX,maxY'.
-            power (float, optional): Power parameter for IDW. default: 2.0
-            smoothing (float, optional): Smoothing parameter for IDW. default: 0.0
-            max_points (int, optional): Maximum number of neighbors to use. default: 16
-            radius (int, optional): Search radius in map units. default: 1000
-            nodata (int, optional): NoData value for the output raster. default: -9999
-            out_dtype (AnalysisDataType, optional): Output data type.
-            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:
-            >>>     vector = await client.get_vector(uuid="12345678-1234-5678-1234-567812345678")
-            >>>     field = await vector.get_field_by_name('field_name')
-            >>>     task = await vector.idw(output_raster_name='test', z_field=field)
-        """
-        from .analysis import Analysis
-        return await Analysis.idw_interpolation(self.api,
-            self,
-            output_raster_name=output_raster_name,
-            z_field=z_field,
-            match_raster_uuid=match_raster_uuid,
-            pixel_size=pixel_size,
-            extent=extent,
-            power=power,
-            smoothing=smoothing,
-            max_points=max_points,
-            radius=radius,
-            nodata=nodata,
-            out_dtype=out_dtype,
-            user_id=user_id)
+        return VectorLayer(api=sync_client, uuid=self.uuid, layer_type=self.layer_type, data=self.data)