channel3-sdk 0.2.1__py3-none-any.whl → 1.0.0__py3-none-any.whl

channel3_sdk/client.py

@@ -1,36 +1,154 @@
 # channel3_sdk/client.py
 import os
-import requests
-from typing import List, Optional, Dict, Any, Union
-import aiohttp
-import asyncio
-from pydantic import ValidationError
+from typing import Any, Dict, List, Optional, Union
 
-from .models import Product, ProductDetail, SearchFilters, SearchRequest, Brand
+from ._gen.fast_api_client.api.channel3_api.get_brand_detail_v0_brands_brand_id_get import (
+    asyncio_detailed as get_brand_asyncio_detailed,
+)
+from ._gen.fast_api_client.api.channel3_api.get_brand_detail_v0_brands_brand_id_get import (
+    sync_detailed as get_brand_sync_detailed,
+)
+from ._gen.fast_api_client.api.channel3_api.get_brands_v0_brands_get import (
+    asyncio_detailed as get_brands_asyncio_detailed,
+)
+from ._gen.fast_api_client.api.channel3_api.get_brands_v0_brands_get import (
+    sync_detailed as get_brands_sync_detailed,
+)
+from ._gen.fast_api_client.api.channel3_api.get_product_detail_v0_products_product_id_get import (
+    asyncio_detailed as get_product_asyncio_detailed,
+)
+from ._gen.fast_api_client.api.channel3_api.get_product_detail_v0_products_product_id_get import (
+    sync_detailed as get_product_sync_detailed,
+)
+from ._gen.fast_api_client.api.channel3_api.search_v0_search_post import (
+    asyncio_detailed as search_asyncio_detailed,
+)
+from ._gen.fast_api_client.api.channel3_api.search_v0_search_post import (
+    sync_detailed as search_sync_detailed,
+)
+
+# Generated client imports
+from ._gen.fast_api_client.client import AuthenticatedClient
+from ._gen.fast_api_client.models.error_response import (
+    ErrorResponse as GenErrorResponse,
+)
+from ._gen.fast_api_client.models.paginated_response_brand import (
+    PaginatedResponseBrand as GenPaginatedResponseBrand,
+)
+from ._gen.fast_api_client.models.product import Product as GenProduct
+from ._gen.fast_api_client.models.product_detail import (
+    ProductDetail as GenProductDetail,
+)
+from ._gen.fast_api_client.models.search_config import (
+    SearchConfig as GenSearchConfig,
+)
+from ._gen.fast_api_client.models.search_filter_price import (
+    SearchFilterPrice as GenSearchFilterPrice,
+)
+from ._gen.fast_api_client.models.search_filters import (
+    SearchFilters as GenSearchFilters,
+)
+from ._gen.fast_api_client.models.search_request import (
+    SearchRequest as GenSearchRequest,
+)
+from ._gen.fast_api_client.types import UNSET
+from ._gen.fast_api_client.types import Response as GenResponse
 from .exceptions import (
-    Channel3Error,
     Channel3AuthenticationError,
-    Channel3ValidationError,
+    Channel3ConnectionError,
+    Channel3Error,
     Channel3NotFoundError,
     Channel3ServerError,
-    Channel3ConnectionError,
+    Channel3ValidationError,
 )
 
 
+def _strip_v0_suffix(base_url: str) -> str:
+    if base_url.endswith("/v0"):
+        return base_url[:-3]
+    return base_url
+
+
+def _convert_filters_to_generated(
+    filters: Optional[GenSearchFilters | Dict[str, Any]],
+) -> Optional[GenSearchFilters]:
+    if filters is None:
+        return None
+    if isinstance(filters, GenSearchFilters):
+        return filters
+    # dict → generated model
+    price = None
+    price_dict = filters.get("price") if isinstance(filters, dict) else None
+    if isinstance(price_dict, dict):
+        price = GenSearchFilterPrice(
+            min_price=price_dict.get("min_price"),
+            max_price=price_dict.get("max_price"),
+        )
+    return GenSearchFilters(
+        brand_ids=filters.get("brand_ids"),  # type: ignore[arg-type]
+        gender=filters.get("gender"),  # type: ignore[arg-type]
+        price=price,
+        availability=filters.get("availability"),  # type: ignore[arg-type]
+    )
+
+
+def _convert_config_to_generated(
+    config: Optional[Union[GenSearchConfig, Dict[str, Any]]],
+) -> Optional[GenSearchConfig]:
+    if config is None:
+        return None
+    if isinstance(config, GenSearchConfig):
+        return config
+    # dict → generated model
+    return GenSearchConfig(
+        enrich_query=config.get("enrich_query", True),
+        semantic_search=config.get("semantic_search", True),
+    )
+
+
+def _raise_for_status(url: str, response: GenResponse[Any]) -> None:
+    status_code = int(response.status_code)
+    data: Dict[str, Any] = {}
+    if response.parsed is not None and isinstance(response.parsed, GenErrorResponse):
+        detail = response.parsed.detail
+        if isinstance(detail, dict):
+            data = detail
+        else:
+            data = {"detail": detail}
+    error_message = data.get("detail") if isinstance(data.get("detail"), str) else None
+    if status_code == 200:
+        return
+    if status_code == 401:
+        raise Channel3AuthenticationError(
+            "Invalid or missing API key", status_code=status_code, response_data=data
+        )
+    if status_code == 404:
+        raise Channel3NotFoundError(
+            error_message or "Resource not found",
+            status_code=status_code,
+            response_data=data,
+        )
+    if status_code == 422:
+        raise Channel3ValidationError(
+            f"Validation error: {error_message or 'Unprocessable Entity'}",
+            status_code=status_code,
+            response_data=data,
+        )
+    if status_code == 500:
+        raise Channel3ServerError(
+            "Internal server error", status_code=status_code, response_data=data
+        )
+    raise Channel3Error(
+        f"Request to {url} failed: {error_message or f'Status {status_code}'}",
+        status_code=status_code,
+        response_data=data,
+    )
+
+
 class BaseChannel3Client:
     """Base client with common functionality."""
 
     def __init__(self, api_key: Optional[str] = None, base_url: Optional[str] = None):
-        """
-        Initialize the base Channel3 client.
-
-        Args:
-            api_key: Your Channel3 API key. If not provided, will look for CHANNEL3_API_KEY in environment.
-            base_url: Base URL for the API. Defaults to https://api.trychannel3.com/v0
-
-        Raises:
-            ValueError: If no API key is provided and none is found in environment variables.
-        """
         self.api_key = api_key or os.getenv("CHANNEL3_API_KEY")
         if not self.api_key:
             raise ValueError(
@@ -40,535 +158,204 @@ class BaseChannel3Client:
         self.base_url = base_url or "https://api.trychannel3.com/v0"
         self.headers = {"x-api-key": self.api_key, "Content-Type": "application/json"}
 
-    def _handle_error_response(
-        self, status_code: int, response_data: Dict[str, Any], url: str
-    ) -> None:
-        """Handle error responses and raise appropriate exceptions."""
-        error_message = response_data.get(
-            "detail", f"Request failed with status {status_code}"
+    def _build_generated_client(self) -> AuthenticatedClient:
+        gen_base_url = _strip_v0_suffix(self.base_url)
+        client = AuthenticatedClient(
+            base_url=gen_base_url,
+            token=self.api_key,
+            prefix="",
+            auth_header_name="x-api-key",
         )
-
-        if status_code == 401:
-            raise Channel3AuthenticationError(
-                "Invalid or missing API key",
-                status_code=status_code,
-                response_data=response_data,
-            )
-        elif status_code == 404:
-            raise Channel3NotFoundError(
-                error_message, status_code=status_code, response_data=response_data
-            )
-        elif status_code == 422:
-            raise Channel3ValidationError(
-                f"Validation error: {error_message}",
-                status_code=status_code,
-                response_data=response_data,
-            )
-        elif status_code == 500:
-            raise Channel3ServerError(
-                "Internal server error",
-                status_code=status_code,
-                response_data=response_data,
-            )
-        else:
-            raise Channel3Error(
-                f"Request to {url} failed: {error_message}",
-                status_code=status_code,
-                response_data=response_data,
-            )
+        client = client.with_headers({"Content-Type": "application/json"})
+        return client
 
 
 class Channel3Client(BaseChannel3Client):
-    """Synchronous Channel3 API client."""
+    """Synchronous Channel3 API client (returns generated models)."""
 
     def search(
         self,
         query: Optional[str] = None,
         image_url: Optional[str] = None,
         base64_image: Optional[str] = None,
-        filters: Optional[SearchFilters] = None,
+        filters: Optional[Union[GenSearchFilters, Dict[str, Any]]] = None,
         limit: int = 20,
-    ) -> List[Product]:
-        """
-        Search for products using text query, image, or both with optional filters.
-
-        Args:
-            query: Text search query
-            image_url: URL to an image to use for visual search
-            base64_image: Base64-encoded image to use for visual search
-            filters: Search filters (SearchFilters object)
-            limit: Maximum number of products to return (default: 20)
-
-        Returns:
-            List of Product objects
-
-        Raises:
-            Channel3AuthenticationError: If API key is invalid
-            Channel3ValidationError: If request parameters are invalid
-            Channel3ServerError: If server encounters an error
-            Channel3ConnectionError: If there are connection issues
-
-        Examples:
-            ```python
-            # Text search
-            products = client.search(query="blue denim jacket")
-
-            # Image search
-            products = client.search(image_url="https://example.com/image.jpg")
-
-            # Multimodal search with filters
-            from channel3_sdk.models import SearchFilters
-            filters = SearchFilters(min_price=50.0, max_price=150.0)
-            products = client.search(query="denim jacket", filters=filters)
-            ```
-        """
-        # Build request payload
-        search_request = SearchRequest(
+        config: Optional[Union[GenSearchConfig, Dict[str, Any]]] = None,
+        context: Optional[str] = None,
+    ) -> List[GenProduct]:
+        gen_client = self._build_generated_client()
+        request_body = GenSearchRequest(
             query=query,
             image_url=image_url,
             base64_image=base64_image,
-            filters=filters,
+            filters=_convert_filters_to_generated(filters)
+            if filters is not None
+            else UNSET,  # type: ignore[arg-type]
             limit=limit,
+            config=_convert_config_to_generated(config)
+            if config is not None
+            else UNSET,  # type: ignore[arg-type]
+            context=context,
         )
 
-        url = f"{self.base_url}/search"
-
         try:
-            response = requests.post(
-                url,
-                json=search_request.model_dump(exclude_none=True),
-                headers=self.headers,
-                timeout=30,
-            )
-
-            response_data = response.json()
-
-            if response.status_code != 200:
-                self._handle_error_response(response.status_code, response_data, url)
-
-            # Parse and validate response
-            return [Product(**item) for item in response_data]
+            response = search_sync_detailed(client=gen_client, body=request_body)
+            self._raise_and_validate_search(response)
+            return response.parsed  # type: ignore[return-value]
+        except Exception as e:
+            if isinstance(e, Channel3Error):
+                raise
+            raise Channel3ConnectionError(f"Request failed: {str(e)}")
+
+    def _raise_and_validate_search(
+        self, response: GenResponse[Union[GenErrorResponse, List[Any]]]
+    ) -> None:
+        url = f"{_strip_v0_suffix(self.base_url)}/v0/search"
+        _raise_for_status(url, response)
+        if not isinstance(response.parsed, list):
+            raise Channel3Error("Invalid response format: expected list of products")
 
-        except requests.exceptions.ConnectionError as e:
-            raise Channel3ConnectionError(
-                f"Failed to connect to Channel3 API: {str(e)}"
-            )
-        except requests.exceptions.Timeout as e:
-            raise Channel3ConnectionError(f"Request timed out: {str(e)}")
-        except requests.exceptions.RequestException as e:
-            raise Channel3Error(f"Request failed: {str(e)}")
-        except ValidationError as e:
-            raise Channel3Error(f"Invalid response format: {str(e)}")
-
-    def get_product(self, product_id: str) -> ProductDetail:
-        """
-        Get detailed information about a specific product by its ID.
-
-        Args:
-            product_id: The unique identifier of the product
-
-        Returns:
-            ProductDetail object with detailed product information
-
-        Raises:
-            Channel3AuthenticationError: If API key is invalid
-            Channel3NotFoundError: If product is not found
-            Channel3ValidationError: If product_id is invalid
-            Channel3ServerError: If server encounters an error
-            Channel3ConnectionError: If there are connection issues
-
-        Example:
-            ```python
-            product_detail = client.get_product("prod_123456")
-            print(f"Product: {product_detail.title}")
-            print(f"Brand: {product_detail.brand_name}")
-            ```
-        """
+    def get_product(self, product_id: str) -> GenProductDetail:
         if not product_id or not product_id.strip():
             raise ValueError("product_id cannot be empty")
 
-        url = f"{self.base_url}/products/{product_id}"
-
+        gen_client = self._build_generated_client()
         try:
-            response = requests.get(url, headers=self.headers, timeout=30)
-            response_data = response.json()
-
-            if response.status_code != 200:
-                self._handle_error_response(response.status_code, response_data, url)
-
-            # Parse and validate response
-            return ProductDetail(**response_data)
-
-        except requests.exceptions.ConnectionError as e:
-            raise Channel3ConnectionError(
-                f"Failed to connect to Channel3 API: {str(e)}"
+            response = get_product_sync_detailed(
+                product_id=product_id, client=gen_client
             )
-        except requests.exceptions.Timeout as e:
-            raise Channel3ConnectionError(f"Request timed out: {str(e)}")
-        except requests.exceptions.RequestException as e:
-            raise Channel3Error(f"Request failed: {str(e)}")
-        except ValidationError as e:
-            raise Channel3Error(f"Invalid response format: {str(e)}")
+            url = f"{_strip_v0_suffix(self.base_url)}/v0/products/{product_id}"
+            _raise_for_status(url, response)
+            return response.parsed  # type: ignore[return-value]
+        except Exception as e:
+            if isinstance(e, Channel3Error):
+                raise
+            raise Channel3ConnectionError(f"Request failed: {str(e)}")
 
     def get_brands(
         self,
         query: Optional[str] = None,
         page: int = 1,
         size: int = 100,
-    ) -> List[Brand]:
-        """
-        Get all brands that the vendor currently sells.
-
-        Args:
-            query: Optional text query to filter brands
-            page: Page number for pagination (default: 1)
-            size: Number of brands per page (default: 100)
-
-        Returns:
-            List of Brand objects
-
-        Raises:
-            Channel3AuthenticationError: If API key is invalid
-            Channel3ValidationError: If request parameters are invalid
-            Channel3ServerError: If server encounters an error
-            Channel3ConnectionError: If there are connection issues
-
-        Example:
-            ```python
-            brands = client.get_brands()
-            for brand in brands:
-                print(f"Brand: {brand.name}")
-            ```
-        """
-        url = f"{self.base_url}/brands"
-        params = {}
-
-        if query is not None:
-            params["query"] = query
-        if page != 1:
-            params["page"] = page
-        if size != 100:
-            params["size"] = size
-
+    ) -> GenPaginatedResponseBrand:
+        gen_client = self._build_generated_client()
         try:
-            response = requests.get(
-                url, headers=self.headers, params=params, timeout=30
+            response = get_brands_sync_detailed(
+                client=gen_client, query=query, page=page, size=size
             )
-            response_data = response.json()
-
-            if response.status_code != 200:
-                self._handle_error_response(response.status_code, response_data, url)
-
-            # Parse and validate response
-            return [Brand(**item) for item in response_data]
-
-        except requests.exceptions.ConnectionError as e:
-            raise Channel3ConnectionError(
-                f"Failed to connect to Channel3 API: {str(e)}"
-            )
-        except requests.exceptions.Timeout as e:
-            raise Channel3ConnectionError(f"Request timed out: {str(e)}")
-        except requests.exceptions.RequestException as e:
-            raise Channel3Error(f"Request failed: {str(e)}")
-        except ValidationError as e:
-            raise Channel3Error(f"Invalid response format: {str(e)}")
-
-    def get_brand(self, brand_id: str) -> Brand:
-        """
-        Get detailed information for a specific brand by its ID.
-
-        Args:
-            brand_id: The unique identifier of the brand
-
-        Returns:
-            Brand object with detailed brand information
-
-        Raises:
-            Channel3AuthenticationError: If API key is invalid
-            Channel3NotFoundError: If brand is not found
-            Channel3ValidationError: If brand_id is invalid
-            Channel3ServerError: If server encounters an error
-            Channel3ConnectionError: If there are connection issues
-
-        Example:
-            ```python
-            brand = client.get_brand("brand_123456")
-            print(f"Brand: {brand.name}")
-            print(f"Description: {brand.description}")
-            ```
-        """
+            url = f"{_strip_v0_suffix(self.base_url)}/v0/brands"
+            _raise_for_status(url, response)
+            return response.parsed  # type: ignore[return-value]
+        except Exception as e:
+            if isinstance(e, Channel3Error):
+                raise
+            raise Channel3ConnectionError(f"Request failed: {str(e)}")
+
+    def get_brand(self, brand_id: str) -> Any:
         if not brand_id or not brand_id.strip():
             raise ValueError("brand_id cannot be empty")
 
-        url = f"{self.base_url}/brands/{brand_id}"
-
+        gen_client = self._build_generated_client()
         try:
-            response = requests.get(url, headers=self.headers, timeout=30)
-            response_data = response.json()
-
-            if response.status_code != 200:
-                self._handle_error_response(response.status_code, response_data, url)
-
-            # Parse and validate response
-            return Brand(**response_data)
-
-        except requests.exceptions.ConnectionError as e:
-            raise Channel3ConnectionError(
-                f"Failed to connect to Channel3 API: {str(e)}"
-            )
-        except requests.exceptions.Timeout as e:
-            raise Channel3ConnectionError(f"Request timed out: {str(e)}")
-        except requests.exceptions.RequestException as e:
-            raise Channel3Error(f"Request failed: {str(e)}")
-        except ValidationError as e:
-            raise Channel3Error(f"Invalid response format: {str(e)}")
+            response = get_brand_sync_detailed(brand_id=brand_id, client=gen_client)
+            url = f"{_strip_v0_suffix(self.base_url)}/v0/brands/{brand_id}"
+            _raise_for_status(url, response)
+            return response.parsed
+        except Exception as e:
+            if isinstance(e, Channel3Error):
+                raise
+            raise Channel3ConnectionError(f"Request failed: {str(e)}")
 
 
 class AsyncChannel3Client(BaseChannel3Client):
-    """Asynchronous Channel3 API client."""
+    """Asynchronous Channel3 API client (returns generated models)."""
 
     async def search(
         self,
         query: Optional[str] = None,
         image_url: Optional[str] = None,
         base64_image: Optional[str] = None,
-        filters: Optional[Union[SearchFilters, Dict[str, Any]]] = None,
+        filters: Optional[Union[GenSearchFilters, Dict[str, Any]]] = None,
         limit: int = 20,
-    ) -> List[Product]:
-        """
-        Search for products using text query, image, or both with optional filters.
-
-        Args:
-            query: Text search query
-            image_url: URL to an image to use for visual search
-            base64_image: Base64-encoded image to use for visual search
-            filters: Search filters (SearchFilters object or dict)
-            limit: Maximum number of products to return (default: 20)
-
-        Returns:
-            List of Product objects
-
-        Raises:
-            Channel3AuthenticationError: If API key is invalid
-            Channel3ValidationError: If request parameters are invalid
-            Channel3ServerError: If server encounters an error
-            Channel3ConnectionError: If there are connection issues
-
-        Examples:
-            ```python
-            # Text search
-            products = await async_client.search(query="blue denim jacket")
-
-            # Image search
-            products = await async_client.search(image_url="https://example.com/image.jpg")
-            ```
-        """
-        # Build request payload
-        search_request = SearchRequest(
+        config: Optional[Union[GenSearchConfig, Dict[str, Any]]] = None,
+        context: Optional[str] = None,
+    ) -> List[GenProduct]:
+        gen_client = self._build_generated_client()
+        request_body = GenSearchRequest(
             query=query,
             image_url=image_url,
             base64_image=base64_image,
-            filters=filters or SearchFilters(),
+            filters=_convert_filters_to_generated(filters)
+            if filters is not None
+            else UNSET,  # type: ignore[arg-type]
             limit=limit,
+            config=_convert_config_to_generated(config)
+            if config is not None
+            else UNSET,  # type: ignore[arg-type]
+            context=context,
         )
 
-        url = f"{self.base_url}/search"
-
         try:
-            async with aiohttp.ClientSession() as session:
-                async with session.post(
-                    url,
-                    json=search_request.model_dump(exclude_none=True),
-                    headers=self.headers,
-                    timeout=aiohttp.ClientTimeout(total=30),
-                ) as response:
-                    response_data = await response.json()
-
-                    if response.status != 200:
-                        self._handle_error_response(response.status, response_data, url)
-
-                    # Parse and validate response
-                    return [Product(**item) for item in response_data]
-
-        except aiohttp.ClientConnectionError as e:
-            raise Channel3ConnectionError(
-                f"Failed to connect to Channel3 API: {str(e)}"
+            response = await search_asyncio_detailed(
+                client=gen_client, body=request_body
             )
-        except asyncio.TimeoutError as e:
-            raise Channel3ConnectionError(f"Request timed out: {str(e)}")
-        except aiohttp.ClientError as e:
-            raise Channel3Error(f"Request failed: {str(e)}")
-        except ValidationError as e:
-            raise Channel3Error(f"Invalid response format: {str(e)}")
-
-    async def get_product(self, product_id: str) -> ProductDetail:
-        """
-        Get detailed information about a specific product by its ID.
-
-        Args:
-            product_id: The unique identifier of the product
-
-        Returns:
-            ProductDetail object with detailed product information
-
-        Raises:
-            Channel3AuthenticationError: If API key is invalid
-            Channel3NotFoundError: If product is not found
-            Channel3ValidationError: If product_id is invalid
-            Channel3ServerError: If server encounters an error
-            Channel3ConnectionError: If there are connection issues
-
-        Example:
-            ```python
-            product_detail = await async_client.get_product("prod_123456")
-            print(f"Product: {product_detail.title}")
-            ```
-        """
+            url = f"{_strip_v0_suffix(self.base_url)}/v0/search"
+            _raise_for_status(url, response)
+            return response.parsed  # type: ignore[return-value]
+        except Exception as e:
+            if isinstance(e, Channel3Error):
+                raise
+            raise Channel3ConnectionError(f"Request failed: {str(e)}")
+
+    async def get_product(self, product_id: str) -> GenProductDetail:
         if not product_id or not product_id.strip():
             raise ValueError("product_id cannot be empty")
 
-        url = f"{self.base_url}/products/{product_id}"
-
+        gen_client = self._build_generated_client()
         try:
-            async with aiohttp.ClientSession() as session:
-                async with session.get(
-                    url, headers=self.headers, timeout=aiohttp.ClientTimeout(total=30)
-                ) as response:
-                    response_data = await response.json()
-
-                    if response.status != 200:
-                        self._handle_error_response(response.status, response_data, url)
-
-                    # Parse and validate response
-                    return ProductDetail(**response_data)
-
-        except aiohttp.ClientConnectionError as e:
-            raise Channel3ConnectionError(
-                f"Failed to connect to Channel3 API: {str(e)}"
+            response = await get_product_asyncio_detailed(
+                product_id=product_id, client=gen_client
             )
-        except asyncio.TimeoutError as e:
-            raise Channel3ConnectionError(f"Request timed out: {str(e)}")
-        except aiohttp.ClientError as e:
-            raise Channel3Error(f"Request failed: {str(e)}")
-        except ValidationError as e:
-            raise Channel3Error(f"Invalid response format: {str(e)}")
+            url = f"{_strip_v0_suffix(self.base_url)}/v0/products/{product_id}"
+            _raise_for_status(url, response)
+            return response.parsed  # type: ignore[return-value]
+        except Exception as e:
+            if isinstance(e, Channel3Error):
+                raise
+            raise Channel3ConnectionError(f"Request failed: {str(e)}")
 
     async def get_brands(
         self,
         query: Optional[str] = None,
         page: int = 1,
         size: int = 100,
-    ) -> List[Brand]:
-        """
-        Get all brands that the vendor currently sells.
-
-        Args:
-            query: Optional text query to filter brands
-            page: Page number for pagination (default: 1)
-            size: Number of brands per page (default: 100)
-
-        Returns:
-            List of Brand objects
-
-        Raises:
-            Channel3AuthenticationError: If API key is invalid
-            Channel3ValidationError: If request parameters are invalid
-            Channel3ServerError: If server encounters an error
-            Channel3ConnectionError: If there are connection issues
-
-        Example:
-            ```python
-            brands = await async_client.get_brands()
-            for brand in brands:
-                print(f"Brand: {brand.name}")
-            ```
-        """
-        url = f"{self.base_url}/brands"
-        params = {}
-
-        if query is not None:
-            params["query"] = query
-        if page != 1:
-            params["page"] = page
-        if size != 100:
-            params["size"] = size
-
+    ) -> GenPaginatedResponseBrand:
+        gen_client = self._build_generated_client()
         try:
-            async with aiohttp.ClientSession() as session:
-                async with session.get(
-                    url,
-                    headers=self.headers,
-                    params=params,
-                    timeout=aiohttp.ClientTimeout(total=30),
-                ) as response:
-                    response_data = await response.json()
-
-                    if response.status != 200:
-                        self._handle_error_response(response.status, response_data, url)
-
-                    # Parse and validate response
-                    return [Brand(**item) for item in response_data]
-
-        except aiohttp.ClientConnectionError as e:
-            raise Channel3ConnectionError(
-                f"Failed to connect to Channel3 API: {str(e)}"
+            response = await get_brands_asyncio_detailed(
+                client=gen_client, query=query, page=page, size=size
             )
-        except asyncio.TimeoutError as e:
-            raise Channel3ConnectionError(f"Request timed out: {str(e)}")
-        except aiohttp.ClientError as e:
-            raise Channel3Error(f"Request failed: {str(e)}")
-        except ValidationError as e:
-            raise Channel3Error(f"Invalid response format: {str(e)}")
-
-    async def get_brand(self, brand_id: str) -> Brand:
-        """
-        Get detailed information for a specific brand by its ID.
-
-        Args:
-            brand_id: The unique identifier of the brand
-
-        Returns:
-            Brand object with detailed brand information
-
-        Raises:
-            Channel3AuthenticationError: If API key is invalid
-            Channel3NotFoundError: If brand is not found
-            Channel3ValidationError: If brand_id is invalid
-            Channel3ServerError: If server encounters an error
-            Channel3ConnectionError: If there are connection issues
-
-        Example:
-            ```python
-            brand = await async_client.get_brand("brand_123456")
-            print(f"Brand: {brand.name}")
-            print(f"Description: {brand.description}")
-            ```
-        """
+            url = f"{_strip_v0_suffix(self.base_url)}/v0/brands"
+            _raise_for_status(url, response)
+            return response.parsed  # type: ignore[return-value]
+        except Exception as e:
+            if isinstance(e, Channel3Error):
+                raise
+            raise Channel3ConnectionError(f"Request failed: {str(e)}")
+
+    async def get_brand(self, brand_id: str) -> Any:
         if not brand_id or not brand_id.strip():
             raise ValueError("brand_id cannot be empty")
 
-        url = f"{self.base_url}/brands/{brand_id}"
-
+        gen_client = self._build_generated_client()
         try:
-            async with aiohttp.ClientSession() as session:
-                async with session.get(
-                    url, headers=self.headers, timeout=aiohttp.ClientTimeout(total=30)
-                ) as response:
-                    response_data = await response.json()
-
-                    if response.status != 200:
-                        self._handle_error_response(response.status, response_data, url)
-
-                    # Parse and validate response
-                    return Brand(**response_data)
-
-        except aiohttp.ClientConnectionError as e:
-            raise Channel3ConnectionError(
-                f"Failed to connect to Channel3 API: {str(e)}"
+            response = await get_brand_asyncio_detailed(
+                brand_id=brand_id, client=gen_client
             )
-        except asyncio.TimeoutError as e:
-            raise Channel3ConnectionError(f"Request timed out: {str(e)}")
-        except aiohttp.ClientError as e:
-            raise Channel3Error(f"Request failed: {str(e)}")
-        except ValidationError as e:
-            raise Channel3Error(f"Invalid response format: {str(e)}")
+            url = f"{_strip_v0_suffix(self.base_url)}/v0/brands/{brand_id}"
+            _raise_for_status(url, response)
+            return response.parsed  # type: ignore[return-value]
+        except Exception as e:
+            if isinstance(e, Channel3Error):
+                raise
+            raise Channel3ConnectionError(f"Request failed: {str(e)}")