cognite-toolkit 0.7.39__py3-none-any.whl → 0.7.51__py3-none-any.whl

cognite_toolkit/_cdf_tk/client/api/location_filters.py

@@ -0,0 +1,177 @@
+from collections.abc import Iterable, Sequence
+
+from cognite_toolkit._cdf_tk.client.cdf_client import CDFResourceAPI, PagedResponse
+from cognite_toolkit._cdf_tk.client.cdf_client.api import Endpoint
+from cognite_toolkit._cdf_tk.client.http_client import (
+    HTTPClient,
+    ItemsSuccessResponse2,
+    RequestMessage2,
+    SuccessResponse2,
+)
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import InternalId
+from cognite_toolkit._cdf_tk.client.resource_classes.location_filter import (
+    LocationFilterRequest,
+    LocationFilterResponse,
+)
+from cognite_toolkit._cdf_tk.utils.collection import chunker_sequence
+
+
+class LocationFiltersAPI(CDFResourceAPI[InternalId, LocationFilterRequest, LocationFilterResponse]):
+    """API for managing Location Filters using the CDFResourceAPI pattern.
+
+    This API manages location filter configurations at:
+    /apps/v1/projects/{project}/storage/config/locationfilters
+    """
+
+    BASE_PATH = "/storage/config/locationfilters"
+
+    def __init__(self, http_client: HTTPClient) -> None:
+        super().__init__(
+            http_client=http_client,
+            method_endpoint_map={
+                "create": Endpoint(method="POST", path=self.BASE_PATH, item_limit=1),
+                "retrieve": Endpoint(method="POST", path=f"{self.BASE_PATH}/byids", item_limit=1000),
+                "update": Endpoint(method="PUT", path=f"{self.BASE_PATH}/{{id}}", item_limit=1),
+                "delete": Endpoint(method="DELETE", path=f"{self.BASE_PATH}/{{id}}", item_limit=1),
+                "list": Endpoint(method="POST", path=f"{self.BASE_PATH}/list", item_limit=1000),
+            },
+        )
+
+    def _make_url(self, path: str = "") -> str:
+        """Create the full URL for this resource endpoint using the apps URL format."""
+        return self._http_client.config.create_app_url(path)
+
+    def _validate_page_response(
+        self, response: SuccessResponse2 | ItemsSuccessResponse2
+    ) -> PagedResponse[LocationFilterResponse]:
+        return PagedResponse[LocationFilterResponse].model_validate_json(response.body)
+
+    def create(self, items: Sequence[LocationFilterRequest]) -> list[LocationFilterResponse]:
+        """Create a new location filter.
+
+        Args:
+            items: The location filter to create.
+
+        Returns:
+            The created location filter.
+        """
+        endpoint = self._method_endpoint_map["create"]
+        results: list[LocationFilterResponse] = []
+        for item in items:
+            request = RequestMessage2(
+                endpoint_url=self._make_url(endpoint.path),
+                method=endpoint.method,
+                body_content=item.model_dump(mode="json", by_alias=True),
+            )
+            result = self._http_client.request_single_retries(request)
+            response = result.get_success_or_raise()
+            results.append(LocationFilterResponse.model_validate_json(response.body))
+        return results
+
+    def retrieve(self, items: Sequence[InternalId]) -> list[LocationFilterResponse]:
+        """Retrieve a single location filter by ID.
+
+        Args:
+            items: The ID of the location filter to retrieve.
+
+        Returns:
+            The retrieved location filter.
+        """
+        endpoint = self._method_endpoint_map["retrieve"]
+        results: list[LocationFilterResponse] = []
+        for chunk in chunker_sequence(items, endpoint.item_limit):
+            request = RequestMessage2(
+                endpoint_url=self._make_url(endpoint.path),
+                method=endpoint.method,
+                body_content={"ids": [item.id for item in chunk]},
+            )
+            result = self._http_client.request_single_retries(request)
+            response = result.get_success_or_raise()
+            results.extend(self._validate_page_response(response).items)
+        return results
+
+    def update(self, items: Sequence[LocationFilterRequest]) -> list[LocationFilterResponse]:
+        """Update an existing location filter.
+
+        Args:
+            items: The updated location filter data.
+
+        Returns:
+            The updated location filter.
+        """
+        endpoint = self._method_endpoint_map["update"]
+        results: list[LocationFilterResponse] = []
+        for item in items:
+            if item.id is None:
+                raise ValueError("Item must have an ID for update operation.")
+            request = RequestMessage2(
+                endpoint_url=self._make_url(endpoint.path.format(id=item.id)),
+                method=endpoint.method,
+                body_content=item.model_dump(mode="json", by_alias=True),
+            )
+            result = self._http_client.request_single_retries(request)
+            response = result.get_success_or_raise()
+            parsed = LocationFilterResponse.model_validate_json(response.body)
+            parsed.id = item.id
+            results.append(parsed)
+        return results
+
+    def delete(self, items: Sequence[InternalId]) -> list[LocationFilterResponse]:
+        """Delete a location filter.
+
+        Args:
+            items: The ID of the location filter to delete.
+
+        Returns:
+            list[LocationFilterResponse]: The deleted location filters.
+        """
+        endpoint = self._method_endpoint_map["delete"]
+        results: list[LocationFilterResponse] = []
+        for item in items:
+            request = RequestMessage2(
+                endpoint_url=self._make_url(endpoint.path.format(id=item.id)),
+                method=endpoint.method,
+            )
+            result = self._http_client.request_single_retries(request)
+            response = result.get_success_or_raise()
+            results.append(LocationFilterResponse.model_validate_json(response.body))
+        return results
+
+    def paginate(
+        self,
+        flat: bool = True,
+    ) -> PagedResponse[LocationFilterResponse]:
+        """Get a single page of location filters.
+
+        Args:
+            flat: Whether to return a flat list (default True).
+
+        Returns:
+            PagedResponse of LocationFilterResponse objects.
+        """
+        return self._paginate(cursor=None, limit=100, body={"flat": flat})
+
+    def iterate(
+        self,
+        flat: bool = True,
+    ) -> Iterable[list[LocationFilterResponse]]:
+        """Iterate over all location filters.
+
+        Args:
+            flat: Whether to return a flat list (default True).
+
+        Returns:
+            Iterable of lists of LocationFilterResponse objects.
+        """
+        return self._iterate(limit=None, body={"flat": flat})
+
+    def list(self, flat: bool = True) -> list[LocationFilterResponse]:
+        """List all location filters.
+
+        Args:
+            flat: Whether to return a flat list (default True).
+
+        Returns:
+            List of LocationFilterResponse objects.
+        """
+        return self._list(limit=None, body={"flat": flat})

cognite_toolkit/_cdf_tk/client/api/migration.py

@@ -17,7 +17,7 @@ from cognite.client.data_classes.data_modeling import (
 from cognite.client.utils.useful_types import SequenceNotStr
 
 from cognite_toolkit._cdf_tk.client.api.legacy.extended_data_modeling import ExtendedInstancesAPI
-from cognite_toolkit._cdf_tk.client.data_classes.legacy.migration import (
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.migration import (
     AssetCentricId,
     CreatedSourceSystem,
     InstanceSource,

cognite_toolkit/_cdf_tk/client/api/project.py

@@ -1,8 +1,8 @@
 from cognite.client import CogniteClient
 
 from cognite_toolkit._cdf_tk.client.config import ToolkitClientConfig
-from cognite_toolkit._cdf_tk.client.data_classes.legacy.project import ProjectStatusList
-from cognite_toolkit._cdf_tk.utils.http_client import HTTPClient, RequestMessage2
+from cognite_toolkit._cdf_tk.client.http_client import HTTPClient, RequestMessage2
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.project import ProjectStatusList
 
 
 class ProjectAPI:

cognite_toolkit/_cdf_tk/client/api/raw.py

@@ -0,0 +1,204 @@
+from collections.abc import Iterable, Sequence
+
+from cognite_toolkit._cdf_tk.client.cdf_client import CDFResourceAPI, Endpoint, PagedResponse, ResponseItems
+from cognite_toolkit._cdf_tk.client.http_client import HTTPClient, ItemsSuccessResponse2, SuccessResponse2
+from cognite_toolkit._cdf_tk.client.resource_classes.raw import RAWDatabase, RAWTable
+
+
+class RawDatabasesAPI(CDFResourceAPI[RAWDatabase, RAWDatabase, RAWDatabase]):
+    """API for managing RAW databases in CDF.
+
+    This API provides methods to create, list, and delete RAW databases.
+    """
+
+    def __init__(self, http_client: HTTPClient) -> None:
+        super().__init__(
+            http_client,
+            {
+                "create": Endpoint(method="POST", path="/raw/dbs", item_limit=1000),
+                "delete": Endpoint(method="POST", path="/raw/dbs/delete", item_limit=1000),
+                "list": Endpoint(method="GET", path="/raw/dbs", item_limit=1000),
+            },
+        )
+
+    def _validate_page_response(self, response: SuccessResponse2 | ItemsSuccessResponse2) -> PagedResponse[RAWDatabase]:
+        return PagedResponse[RAWDatabase].model_validate_json(response.body)
+
+    def _reference_response(self, response: SuccessResponse2) -> ResponseItems[RAWDatabase]:
+        return ResponseItems[RAWDatabase].model_validate_json(response.body)
+
+    def create(self, items: Sequence[RAWDatabase]) -> list[RAWDatabase]:
+        """Create databases in CDF.
+
+        Args:
+            items: List of RAWDatabase objects to create.
+
+        Returns:
+            List of created RAWDatabase objects.
+        """
+        return self._request_item_response(list(items), "create")
+
+    def delete(self, items: Sequence[RAWDatabase], recursive: bool = False) -> None:
+        """Delete databases from CDF.
+
+        Args:
+            items: List of RAWDatabase objects to delete.
+            recursive: Whether to delete tables within the database recursively.
+        """
+        self._request_no_response(list(items), "delete", extra_body={"recursive": recursive})
+
+    def paginate(
+        self,
+        limit: int = 100,
+        cursor: str | None = None,
+    ) -> PagedResponse[RAWDatabase]:
+        """Iterate over all databases in CDF.
+
+        Args:
+            limit: Maximum number of items to return.
+            cursor: Cursor for pagination.
+
+        Returns:
+            PagedResponse of RAWDatabase objects.
+        """
+        return self._paginate(limit=limit, cursor=cursor)
+
+    def iterate(
+        self,
+        limit: int = 100,
+    ) -> Iterable[list[RAWDatabase]]:
+        """Iterate over all databases in CDF.
+
+        Args:
+            limit: Maximum number of items to return per page.
+
+        Returns:
+            Iterable of lists of RAWDatabase objects.
+        """
+        return self._iterate(limit=limit)
+
+    def list(self, limit: int | None = None) -> list[RAWDatabase]:
+        """List all databases in CDF.
+
+        Args:
+            limit: Maximum number of databases to return. If None, returns all databases.
+
+        Returns:
+            List of RAWDatabase objects.
+        """
+        return self._list(limit=limit)
+
+
+class RawTablesAPI(CDFResourceAPI[RAWTable, RAWTable, RAWTable]):
+    """API for managing RAW tables in CDF.
+
+    This API provides methods to create, list, and delete RAW tables within a database.
+
+    Note: This API requires db_name as a path parameter for all operations,
+    so it overrides several base class methods to handle dynamic paths.
+    """
+
+    def __init__(self, http_client: HTTPClient) -> None:
+        # We pass empty endpoint map since paths are dynamic (depend on db_name)
+        super().__init__(
+            http_client,
+            {
+                "create": Endpoint(method="POST", path="/raw/dbs/{dbName}/tables", item_limit=1000),
+                "delete": Endpoint(method="POST", path="/raw/dbs/{dbName}/tables/delete", item_limit=1000),
+                "list": Endpoint(method="GET", path="/raw/dbs/{dbName}/tables", item_limit=1000),
+            },
+        )
+
+    def _validate_page_response(self, response: SuccessResponse2 | ItemsSuccessResponse2) -> PagedResponse[RAWTable]:
+        """Parse a page response. Note: db_name must be injected separately."""
+        return PagedResponse[RAWTable].model_validate_json(response.body)
+
+    def _reference_response(self, response: SuccessResponse2) -> ResponseItems[RAWTable]:
+        """Parse a reference response. Note: db_name must be injected separately."""
+        return ResponseItems[RAWTable].model_validate_json(response.body)
+
+    def create(self, items: Sequence[RAWTable], ensure_parent: bool = False) -> list[RAWTable]:
+        """Create tables in a database in CDF.
+
+        Args:
+            items: List of RAWTable objects to create.
+            ensure_parent: Create database if it doesn't exist already.
+
+        Returns:
+            List of created RAWTable objects.
+        """
+        result: list[RAWTable] = []
+        for (db_name,), group in self._group_items_by_text_field(items, "db_name").items():
+            if not db_name:
+                raise ValueError("db_name must be set on all RAWTable items for creation.")
+            endpoint = f"/raw/dbs/{db_name}/tables"
+            created = self._request_item_response(
+                group, "create", params={"ensureParent": ensure_parent}, endpoint=endpoint
+            )
+            for table in created:
+                result.append(RAWTable(db_name=db_name, name=table.name))
+        return result
+
+    def delete(self, items: Sequence[RAWTable]) -> None:
+        """Delete tables from a database in CDF.
+
+        Args:
+            items: List of RAWTable objects to delete.
+        """
+        for (db_name,), group in self._group_items_by_text_field(items, "db_name").items():
+            if not db_name:
+                raise ValueError("db_name must be set on all RAWTable items for deletion.")
+            endpoint = f"/raw/dbs/{db_name}/tables/delete"
+            self._request_no_response(list(group), "delete", endpoint=endpoint)
+
+    def paginate(
+        self,
+        db_name: str,
+        limit: int = 100,
+        cursor: str | None = None,
+    ) -> PagedResponse[RAWTable]:
+        """Iterate over all tables in a database in CDF.
+
+        Args:
+            db_name: The name of the database to list tables from.
+            limit: Maximum number of items to return.
+            cursor: Cursor for pagination.
+
+        Returns:
+            PagedResponse of RAWTable objects.
+        """
+        return self._paginate(cursor=cursor, limit=limit, endpoint_path=f"/raw/dbs/{db_name}/tables")
+
+    def iterate(
+        self,
+        db_name: str,
+        limit: int = 100,
+    ) -> Iterable[list[RAWTable]]:
+        """Iterate over all tables in a database in CDF.
+
+        Args:
+            db_name: The name of the database to list tables from.
+            limit: Maximum number of items to return per page.
+
+        Returns:
+            Iterable of lists of RAWTable objects.
+        """
+        return self._iterate(limit=limit, endpoint_path=f"/raw/dbs/{db_name}/tables")
+
+    def list(self, db_name: str, limit: int | None = None) -> list[RAWTable]:
+        """List all tables in a database in CDF.
+
+        Args:
+            db_name: The name of the database to list tables from.
+            limit: Maximum number of tables to return. If None, returns all tables.
+
+        Returns:
+            List of RAWTable objects.
+        """
+        return self._list(limit, endpoint_path=f"/raw/dbs/{db_name}/tables")
+
+
+class RawAPI:
+    def __init__(self, http_client: HTTPClient) -> None:
+        self.databases = RawDatabasesAPI(http_client)
+        self.tables = RawTablesAPI(http_client)

cognite_toolkit/_cdf_tk/client/api/relationships.py

@@ -0,0 +1,133 @@
+"""Relationships API for managing CDF relationships.
+
+Based on the API specification at:
+https://api-docs.cognite.com/20230101/tag/Relationships/operation/createRelationships
+"""
+
+from collections.abc import Iterable, Sequence
+from typing import Literal
+
+from cognite_toolkit._cdf_tk.client.cdf_client import CDFResourceAPI, Endpoint, PagedResponse
+from cognite_toolkit._cdf_tk.client.http_client import HTTPClient, ItemsSuccessResponse2, SuccessResponse2
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import ExternalId
+from cognite_toolkit._cdf_tk.client.resource_classes.relationship import RelationshipRequest, RelationshipResponse
+
+
+class RelationshipsAPI(CDFResourceAPI[ExternalId, RelationshipRequest, RelationshipResponse]):
+    """API for managing CDF relationships."""
+
+    def __init__(self, http_client: HTTPClient) -> None:
+        super().__init__(
+            http_client=http_client,
+            method_endpoint_map={
+                "create": Endpoint(method="POST", path="/relationships", item_limit=1000),
+                "retrieve": Endpoint(method="POST", path="/relationships/byids", item_limit=1000),
+                "update": Endpoint(method="POST", path="/relationships/update", item_limit=1000),
+                "delete": Endpoint(method="POST", path="/relationships/delete", item_limit=1000),
+                "list": Endpoint(method="POST", path="/relationships/list", item_limit=1000),
+            },
+        )
+
+    def _validate_page_response(
+        self, response: SuccessResponse2 | ItemsSuccessResponse2
+    ) -> PagedResponse[RelationshipResponse]:
+        return PagedResponse[RelationshipResponse].model_validate_json(response.body)
+
+    def create(self, items: Sequence[RelationshipRequest]) -> list[RelationshipResponse]:
+        """Create relationships in CDF.
+
+        Args:
+            items: List of RelationshipRequest objects to create.
+
+        Returns:
+            List of created RelationshipResponse objects.
+        """
+        return self._request_item_response(items, "create")
+
+    def retrieve(
+        self, items: Sequence[ExternalId], ignore_unknown_ids: bool = False, fetch_resources: bool = False
+    ) -> list[RelationshipResponse]:
+        """Retrieve relationships from CDF.
+
+        Args:
+            items: List of ExternalId objects to retrieve.
+            ignore_unknown_ids: Whether to ignore unknown IDs.
+            fetch_resources: If true, will try to fetch the resources referred to in the relationship,
+                based on the users access rights. Will silently fail to attach the resources
+                if the user lacks access to some of them.
+
+        Returns:
+            List of retrieved RelationshipResponse objects.
+        """
+        return self._request_item_response(
+            items,
+            method="retrieve",
+            extra_body={"ignoreUnknownIds": ignore_unknown_ids, "fetchResources": fetch_resources},
+        )
+
+    def update(
+        self, items: Sequence[RelationshipRequest], mode: Literal["patch", "replace"] = "replace"
+    ) -> list[RelationshipResponse]:
+        """Update relationships in CDF.
+
+        Args:
+            items: List of RelationshipRequest objects to update.
+            mode: Update mode, either "patch" or "replace".
+
+        Returns:
+            List of updated RelationshipResponse objects.
+        """
+        return self._update(items, mode=mode)
+
+    def delete(self, items: Sequence[ExternalId], ignore_unknown_ids: bool = False) -> None:
+        """Delete relationships from CDF.
+
+        Args:
+            items: List of ExternalId objects to delete.
+            ignore_unknown_ids: Whether to ignore unknown IDs.
+        """
+        self._request_no_response(items, "delete", extra_body={"ignoreUnknownIds": ignore_unknown_ids})
+
+    def paginate(
+        self,
+        limit: int = 100,
+        cursor: str | None = None,
+    ) -> PagedResponse[RelationshipResponse]:
+        """Get a page of relationships from CDF.
+
+        Args:
+            limit: Maximum number of relationships to return.
+            cursor: Cursor for pagination.
+
+        Returns:
+            PagedResponse of RelationshipResponse objects.
+        """
+        return self._paginate(
+            cursor=cursor,
+            limit=limit,
+        )
+
+    def iterate(
+        self,
+        limit: int | None = None,
+    ) -> Iterable[list[RelationshipResponse]]:
+        """Iterate over all relationships in CDF.
+
+        Args:
+            limit: Maximum total number of relationships to return.
+
+        Returns:
+            Iterable of lists of RelationshipResponse objects.
+        """
+        return self._iterate(limit=limit)
+
+    def list(self, limit: int | None = None) -> list[RelationshipResponse]:
+        """List all relationships in CDF.
+
+        Args:
+            limit: Maximum total number of relationships to return.
+
+        Returns:
+            List of RelationshipResponse objects.
+        """
+        return self._list(limit=limit)

cognite_toolkit/_cdf_tk/client/api/robotics.py

@@ -0,0 +1,19 @@
+from cognite_toolkit._cdf_tk.client.api.robotics_capabilities import CapabilitiesAPI
+from cognite_toolkit._cdf_tk.client.api.robotics_data_postprocessing import DataPostProcessingAPI
+from cognite_toolkit._cdf_tk.client.api.robotics_frames import FramesAPI
+from cognite_toolkit._cdf_tk.client.api.robotics_locations import LocationsAPI
+from cognite_toolkit._cdf_tk.client.api.robotics_maps import MapsAPI
+from cognite_toolkit._cdf_tk.client.api.robotics_robots import RobotsAPI
+from cognite_toolkit._cdf_tk.client.http_client import HTTPClient
+
+
+class RoboticsAPI:
+    """API for Robotics resources."""
+
+    def __init__(self, http_client: HTTPClient) -> None:
+        self.capabilities = CapabilitiesAPI(http_client)
+        self.data_postprocessing = DataPostProcessingAPI(http_client)
+        self.frames = FramesAPI(http_client)
+        self.locations = LocationsAPI(http_client)
+        self.maps = MapsAPI(http_client)
+        self.robots = RobotsAPI(http_client)

cognite_toolkit/_cdf_tk/client/api/robotics_capabilities.py

@@ -0,0 +1,127 @@
+from collections.abc import Iterable, Sequence
+from typing import Literal
+
+from cognite_toolkit._cdf_tk.client.cdf_client import CDFResourceAPI, PagedResponse, ResponseItems
+from cognite_toolkit._cdf_tk.client.cdf_client.api import Endpoint
+from cognite_toolkit._cdf_tk.client.http_client import HTTPClient, ItemsSuccessResponse2, SuccessResponse2
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import ExternalId
+from cognite_toolkit._cdf_tk.client.resource_classes.robotics._capability import (
+    RobotCapabilityRequest,
+    RobotCapabilityResponse,
+)
+
+
+class CapabilitiesAPI(CDFResourceAPI[ExternalId, RobotCapabilityRequest, RobotCapabilityResponse]):
+    """API for managing Capability resources in CDF."""
+
+    def __init__(self, http_client: HTTPClient) -> None:
+        super().__init__(
+            http_client=http_client,
+            method_endpoint_map={
+                "create": Endpoint(
+                    method="POST", path="/robotics/capabilities", item_limit=1000, concurrency_max_workers=1
+                ),
+                "retrieve": Endpoint(
+                    method="POST", path="/robotics/capabilities/byids", item_limit=1000, concurrency_max_workers=1
+                ),
+                "update": Endpoint(
+                    method="POST", path="/robotics/capabilities/update", item_limit=1000, concurrency_max_workers=1
+                ),
+                "delete": Endpoint(
+                    method="POST", path="/robotics/capabilities/delete", item_limit=1000, concurrency_max_workers=1
+                ),
+                "list": Endpoint(method="GET", path="/robotics/capabilities", item_limit=1000),
+            },
+            disable_gzip=True,
+        )
+
+    def _validate_page_response(
+        self, response: SuccessResponse2 | ItemsSuccessResponse2
+    ) -> PagedResponse[RobotCapabilityResponse]:
+        return PagedResponse[RobotCapabilityResponse].model_validate_json(response.body)
+
+    def _reference_response(self, response: SuccessResponse2) -> ResponseItems[ExternalId]:
+        return ResponseItems[ExternalId].model_validate_json(response.body)
+
+    def create(self, items: Sequence[RobotCapabilityRequest]) -> list[RobotCapabilityResponse]:
+        """Create capabilities in CDF.
+
+        Args:
+            items: List of RobotCapabilityRequest objects to create.
+        Returns:
+            List of created RobotCapabilityResponse objects.
+        """
+        return self._request_item_response(items, "create")
+
+    def retrieve(self, items: Sequence[ExternalId]) -> list[RobotCapabilityResponse]:
+        """Retrieve capabilities from CDF.
+
+        Args:
+            items: List of ExternalId objects to retrieve.
+        Returns:
+            List of retrieved RobotCapabilityResponse objects.
+        """
+        return self._request_item_response(items, method="retrieve")
+
+    def update(
+        self, items: Sequence[RobotCapabilityRequest], mode: Literal["patch", "replace"] = "replace"
+    ) -> list[RobotCapabilityResponse]:
+        """Update capabilities in CDF.
+
+        Args:
+            items: List of RobotCapabilityRequest objects to update.
+            mode: Update mode, either "patch" or "replace".
+
+        Returns:
+            List of updated RobotCapabilityResponse objects.
+        """
+        return self._update(items, mode=mode)
+
+    def delete(self, items: Sequence[ExternalId]) -> None:
+        """Delete capabilities from CDF.
+
+        Args:
+            items: List of ExternalId objects to delete.
+        """
+        self._request_no_response(items, "delete")
+
+    def paginate(
+        self,
+        limit: int = 100,
+        cursor: str | None = None,
+    ) -> PagedResponse[RobotCapabilityResponse]:
+        """Paginate over capabilities in CDF.
+
+        Args:
+            limit: Maximum number of items per page.
+            cursor: Cursor for pagination.
+
+        Returns:
+            PagedResponse of RobotCapabilityResponse objects.
+        """
+        return self._paginate(cursor=cursor, limit=limit)
+
+    def iterate(
+        self,
+        limit: int | None = 100,
+    ) -> Iterable[list[RobotCapabilityResponse]]:
+        """Iterate over all capabilities in CDF.
+
+        Args:
+            limit: Maximum number of items to return. None returns all.
+
+        Returns:
+            Iterable of lists of RobotCapabilityResponse objects.
+        """
+        return self._iterate(limit=limit)
+
+    def list(self, limit: int | None = 100) -> list[RobotCapabilityResponse]:
+        """List all capabilities in CDF.
+
+        Args:
+            limit: Maximum number of items to return. None returns all.
+
+        Returns:
+            List of RobotCapabilityResponse objects.
+        """
+        return self._list(limit=limit)