shopware-api-client 1.0.101__py3-none-any.whl → 1.1.1__py3-none-any.whl

shopware_api_client/endpoints/relations.py

@@ -1,16 +1,16 @@
-from typing import Any, Coroutine, Generic, get_args
+from typing import Any, Coroutine, Generic, get_args, TypeGuard
 
 from pydantic import GetCoreSchemaHandler, ValidationInfo
 from pydantic.alias_generators import to_camel
 from pydantic_core import SchemaValidator, core_schema
 
-from ..base import ApiModelBase, ClientBase, ModelClass
+from shopware_api_client.base import AdminEndpoint, AdminModel, AdminModelClass, ClientBase
 
 
-class ForeignRelation(Generic[ModelClass]):
-    def __init__(self, field_name: str, data: ModelClass | None = None):
+class ForeignRelation(Generic[AdminModelClass]):
+    def __init__(self, field_name: str, data: AdminModelClass | None = None):
         self.field_name: str = field_name
-        self.data: ModelClass | None = data
+        self.data: AdminModelClass | None = data
         self.changed: bool = False
 
     def _ensure_client(self, client: ClientBase | None) -> None:
@@ -36,35 +36,39 @@ class ForeignRelation(Generic[ModelClass]):
         )
 
     @staticmethod
-    def _validate(value: ModelClass | None, info: ValidationInfo) -> "ForeignRelation":
+    def _validate(value: AdminModelClass | None, info: ValidationInfo) -> "ForeignRelation":
         field_name = info.field_name
         assert field_name is not None
         return ForeignRelation(field_name=field_name, data=value)
 
     @staticmethod
-    def _serialize(value: "ForeignRelation[ModelClass]") -> ModelClass | None:
+    def _serialize(value: "ForeignRelation[AdminModelClass]") -> AdminModelClass | None:
         assert isinstance(value, ForeignRelation)
         if value.data is None:
             return None
         return value.data
 
-    async def _get(self, instance: "ApiModelBase[Any]") -> ModelClass | None:
+    async def _get(self, instance: AdminModelClass) -> AdminModelClass | None:
         related_id = getattr(instance, f"{self.field_name}_id")
         if self.data is not None or related_id is None:
             self._ensure_client(instance._client)
             return self.data
 
-        model_class: type[ModelClass] = get_args(instance.model_fields[self.field_name].annotation)[0]
-        data = await model_class.using(instance._get_client()).get(pk=related_id)
+        model_class: type[AdminModelClass] = get_args(instance.model_fields[self.field_name].annotation)[0]
+        endpoint: AdminEndpoint[AdminModelClass] = model_class.using(instance._get_client())
+        data = await endpoint.get(pk=related_id)
+
+        assert data is None or isinstance(data, AdminModel)
+
         self.data = data
         return self.data
 
-    def __get__(self, instance: "ApiModelBase[Any]", owner: type[Any]) -> Coroutine[Any, Any, ModelClass | None]:
+    def __get__(self, instance: AdminModelClass, owner: type[Any]) -> Coroutine[Any, Any, AdminModelClass | None]:
         return self._get(instance=instance)
 
-    def __set__(self, instance: "ApiModelBase[Any]", value: Any) -> None:
+    def __set__(self, instance: AdminModelClass, value: Any) -> None:
         if value is not None:
-            model_class: type[ModelClass] = get_args(instance.model_fields[self.field_name].annotation)[0]
+            model_class: type[AdminModelClass] = get_args(instance.model_fields[self.field_name].annotation)[0]
             model_class.model_validate(value)
 
         # Related models passed to the API win against _id fields, but we can try to
@@ -75,10 +79,10 @@ class ForeignRelation(Generic[ModelClass]):
         self.changed = True
 
 
-class ManyRelation(Generic[ModelClass]):
-    def __init__(self, field_name: str, data: list[ModelClass] | None = None):
+class ManyRelation(Generic[AdminModelClass]):
+    def __init__(self, field_name: str, data: list[AdminModelClass] | None = None):
         self.field_name: str = field_name
-        self.data: list[ModelClass] | None = data
+        self.data: list[AdminModelClass] | None = data
         self.changed: bool = False
 
     def _ensure_client(self, client: ClientBase | None) -> None:
@@ -87,6 +91,10 @@ class ManyRelation(Generic[ModelClass]):
                 if elem._client is None:
                     elem._client = client
 
+    @staticmethod
+    def _assert_admin_model_list(items: list[Any]) -> TypeGuard[list[AdminModelClass]]:
+        return all(isinstance(item, AdminModel) for item in items)
+
     @classmethod
     def __get_pydantic_core_schema__(cls, source: Any, handler: GetCoreSchemaHandler) -> core_schema.CoreSchema:
         assert handler.field_name is not None
@@ -108,34 +116,38 @@ class ManyRelation(Generic[ModelClass]):
         )
 
     @staticmethod
-    def _validate(value: list[ModelClass] | None, info: ValidationInfo) -> "ManyRelation":
+    def _validate(value: list[AdminModelClass] | None, info: ValidationInfo) -> "ManyRelation":
         field_name = info.field_name
         assert field_name is not None
         return ManyRelation(field_name=field_name, data=value)
 
     @staticmethod
-    def _serialize(value: "ManyRelation[ModelClass]") -> list[ModelClass] | None:
+    def _serialize(value: "ManyRelation[AdminModelClass]") -> list[AdminModelClass] | None:
         assert isinstance(value, ManyRelation)
         if value.data is None:
             return None
         return value.data
 
-    async def _get(self, instance: "ApiModelBase[Any]") -> list[ModelClass] | None:
+    async def _get(self, instance: AdminModelClass) -> list[AdminModelClass] | None:
         api_link = to_camel(self.field_name)
         if self.data is not None:
             self._ensure_client(instance._client)
             return self.data
 
-        model_class: type[ModelClass] = get_args(instance.model_fields[self.field_name].annotation)[0]
-        data = await model_class.using(instance._get_client()).get_related(instance, relation=api_link)
+        model_class: type[AdminModelClass] = get_args(instance.model_fields[self.field_name].annotation)[0]
+        endpoint: AdminEndpoint[AdminModelClass] = model_class.using(instance._get_client())
+        data = await endpoint.get_related(instance, relation=api_link)
+
+        assert data is None or self._assert_admin_model_list(data)
+
         self.data = data
         return self.data
 
-    def __get__(self, instance: "ApiModelBase[Any]", owner: type[Any]) -> Coroutine[Any, Any, list[ModelClass] | None]:
+    def __get__(self, instance: AdminModelClass, owner: type[Any]) -> Coroutine[Any, Any, list[AdminModelClass] | None]:
         return self._get(instance=instance)
 
-    def __set__(self, instance: "ApiModelBase[Any]", value: Any) -> None:
-        model_class: type[ModelClass] = get_args(instance.model_fields[self.field_name].annotation)[0]
+    def __set__(self, instance: AdminModelClass, value: Any) -> None:
+        model_class: type[AdminModelClass] = get_args(instance.model_fields[self.field_name].annotation)[0]
         schema = core_schema.list_schema(
             core_schema.model_schema(cls=model_class, schema=model_class.__pydantic_core_schema__)
         )

shopware_api_client/endpoints/store/__init__.py

@@ -1,16 +1,49 @@
-from typing import TYPE_CHECKING
+from typing import Callable, TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from ...client import StoreClient
-
+    from shopware_api_client.client import StoreClient
+    from shopware_api_client.endpoints.base_fields import IdField
 
 from .core.address import Address, AddressEndpoint
 from .core.cart import Cart, CartEndpoint
+from .core.context import Context, ContextEndpoint
+from .core.country import Country, CountryEndpoint
+from .core.country_state import CountryState, CountryStateEndpoint
+from .core.currency import Currency, CurrencyEndpoint
+from .core.customer import Customer, CustomerEndpoint
+from .core.language import Language, LanguageEndpoint
+from .core.order import Order, OrderEndpoint
+from .core.product import Product, ProductEndpoint
+from .core.salutation import Salutation, SalutationEndpoint
 
-__all__ = ["Address", "Cart"]
+__all__ = [
+    "Address",
+    "Cart",
+    "Context",
+    "Country",
+    "CountryState",
+    "Currency",
+    "Customer",
+    "Language",
+    "Order",
+    "Product",
+    "Salutation",
+    "StoreEndpoints",
+]
 
 
 class StoreEndpoints:
     def init_endpoints(self, client: "StoreClient") -> None:
         self.address = AddressEndpoint(client)
         self.cart = CartEndpoint(client)
+        self.country = CountryEndpoint(client)
+        self.context = ContextEndpoint(client)
+        self.country_state: Callable[["IdField"], CountryStateEndpoint] = lambda country_id: CountryStateEndpoint(
+            client=client, country_id=country_id
+        )
+        self.currency = CurrencyEndpoint(client)
+        self.customer = CustomerEndpoint(client)
+        self.language = LanguageEndpoint(client)
+        self.order = OrderEndpoint(client)
+        self.product = ProductEndpoint(client)
+        self.salutation = SalutationEndpoint(client)

shopware_api_client/endpoints/store/core/address.py

@@ -1,78 +1,61 @@
-from typing import Any, AsyncGenerator
-
-from ....base import EndpointBase
-from ....exceptions import SWAPIMethodNotAvailable
-from ...admin.core.country import CountryBase
-from ...admin.core.country_state import CountryStateBase
-from ...admin.core.customer_address import CustomerAddressBase
-from ...admin.core.salutation import SalutationBase
-
-
-class Address(CustomerAddressBase["AddressEndpoint"]):
-    _identifier = "address"
-
-    country: CountryBase | None = None
-    customer_state: CountryStateBase | None = None
-    salutation: SalutationBase | None = None
-
-
-class AddressEndpoint(EndpointBase[Address]):
-    name = "address"
-    path = "/account/address"
+from typing import Any
+
+from shopware_api_client.base import StoreSearchEndpoint, EndpointMixin, CustomFieldsMixin
+from shopware_api_client.endpoints.base_fields import IdField
+from shopware_api_client.fieldsets import FieldSetBase
+from shopware_api_client.models.customer_address import CustomerAddressBase
+
+
+class Address(CustomerAddressBase, EndpointMixin["AddressEndpoint"]):
+    country: "Country | None" = None
+    country_state: "CountryState | None" = None
+    salutation: "Salutation | None" = None
+
+
+class AddressUpdateSchema(FieldSetBase, CustomFieldsMixin):
+    country_id: IdField
+    country_state_id: IdField | None = None
+    salutation_id: IdField | None = None
+    first_name: str
+    last_name: str
+    zipcode: str | None = None
+    city: str
+    company: str | None = None
+    street: str
+    department: str | None = None
+    title: str | None = None
+    phone_number: str | None = None
+    additional_address_line1: str | None = None
+    additional_address_line2: str | None = None
+
+
+class AddressEndpoint(StoreSearchEndpoint[Address]):
     model_class = Address
-    data_key = "elements"
-
-    async def all(self) -> list[Address] | list[dict[str, Any]]:
-        data = self._get_data_dict()
+    path = "/account/list-address"
 
-        result = await self.client.post("/account/list-address", json=data)
+    async def delete(self, pk: IdField) -> bool:
+        result = await self.client.delete(f"/account/address/{pk}")
+        return bool(result.is_success)
 
-        result_data: list[dict[str, Any]] = result.json().get(self.data_key, [])
+    async def modify(self, pk: IdField, obj: AddressUpdateSchema) -> Address:
+        data = obj.model_dump_json(by_alias=True)
+        result: dict[str, Any] = (await self.client.patch(f"/account/address/{pk}", data=data)).json()
+        return self._parse_response(result, Address)
 
-        if self.raw:
-            return result_data
+    async def create(self, obj: AddressUpdateSchema) -> Address:
+        data = obj.model_dump_json(by_alias=True)
+        result: dict[str, Any] = (await self.client.post("/account/address", data=data)).json()
+        return self._parse_response(result, Address)
 
-        return self._parse_response(result_data)
-
-    async def iter(self, batch_size: int = 100) -> AsyncGenerator[Address | dict[str, Any], None]:
-        self._limit = batch_size
-        data = self._get_data_dict()
-        page = 1
-
-        while True:
-            data["page"] = page
-            result = await self.client.post("/account/list-address", json=data)
-
-            result_dict: dict[str, Any] = result.json()
-            result_data: list[dict[str, Any]] = self._parse_data(result_dict)
-
-            for entry in result_data:
-                if self.raw:
-                    yield entry
-                else:
-                    yield self._parse_response(entry)
-
-            if "next" in result_dict.get("links", {}) and len(result_data) > 0:
-                page += 1
-            else:
-                break
-
-    async def set_default_shipping_address(self, pk: str) -> bool:
+    async def set_default_shipping_address(self, pk: IdField) -> bool:
         result = await self.client.patch(f"/account/address/default-shipping/{pk}")
-        return bool(result.status_code == 204)
+        return bool(result.is_success)
 
-    async def set_default_billing_address(self, pk: str) -> bool:
+    async def set_default_billing_address(self, pk: IdField) -> bool:
         result = await self.client.patch(f"/account/address/default-billing/{pk}")
-        return bool(result.status_code == 204)
-
-    async def get(self, pk: str) -> Address | dict[str, Any]:
-        raise SWAPIMethodNotAvailable()
+        return bool(result.is_success)
 
-    async def bulk_upsert(
-        self, objs: list[Address] | list[dict[str, Any]], fail_silently: bool = False, **request_kwargs: Any
-    ) -> dict[str, Any]:
-        raise SWAPIMethodNotAvailable()
 
-    async def bulk_delete(self, objs: list[Address] | list[dict[str, Any]], fail_silently: bool = False, 
-                          **request_kwargs: Any) -> dict[str, Any]:
-        raise SWAPIMethodNotAvailable()
+from .country import Country  # noqa: E402
+from .country_state import CountryState  # noqa: E402
+from .salutation import Salutation  # noqa: E402

shopware_api_client/endpoints/store/core/cart.py

@@ -1,95 +1,49 @@
 from typing import Any
 
-from shopware_api_client.base import ApiModelBase, EndpointBase
-from shopware_api_client.endpoints.admin.core.country import Country
-from shopware_api_client.endpoints.base_fields import BaseFieldSet, IdField, Price
-from shopware_api_client.endpoints.store.core.address import Address
+from shopware_api_client.base import StoreEndpoint, EndpointMixin
+from shopware_api_client.endpoints.base_fields import IdField
+from shopware_api_client.structs.cart import Cart as CartBase
+from shopware_api_client.structs.line_item import LineItem
 
 
-class ItemPrice(BaseFieldSet):
-    unit_price: float
-    quantity: int
-    total_price: float
-    calculated_taxes: list[dict[str, Any]] | None = None
-    tax_rules: list[dict[str, Any]] | None = None
-    reference_price: float | None = None
-    list_price: float | None = None
-    regulation_price: float | None = None
-    
+class Cart(CartBase, EndpointMixin["CartEndpoint"]):
+    pass
 
-class ShippingCosts(ItemPrice):
-    raw_total: float | None = None
-    position_price: float | None = None
-    net_price: float | None = None
-    has_range: bool | None = None
-    variant: str | None = None
 
-
-class LineItem(BaseFieldSet):
-    payload: dict[str, Any]
-    label: str
-    quantity: int
-    price_definition: dict[str, Any]
-    price: ItemPrice
-    good: bool
-    description: str | None = None
-    cover: Any
-    delivery_information: dict[str, Any]
-    children: list[Any]
-    removable: bool
-    stackable: bool
-    quantity_information: dict[str, Any]
-    modified: bool
-    data_timestamp: str
-    data_context_hash: str
-    states: list[str]
-    modified_by_app: bool
-    referenced_id: IdField
-
-
-class DeliveryPosition(BaseFieldSet):
-    delivery_date: Any
-    line_item: LineItem
-    price: ItemPrice
-
-
-class Location(BaseFieldSet):
-    country: Country
-    adress: Address | None = None
-    state: Any | None = None
-    
-
-class CartDelivery(BaseFieldSet):
-    delilvery_date: Any | None = None
-    location: Location | None = None
-    positions: list[DeliveryPosition] | None = None
-    shipping_costs: ShippingCosts | None = None #ShippingCosts 
-    shipping_method: Any | None = None
-
-
-class Cart(ApiModelBase["CartEndpoint"]):
-    _identifier: str = "cart"
-    
-    token: str
-    price: Price
-    line_items: list[LineItem]
-    errors: list[dict[str, Any]] | dict[str, Any] | None = None
-    deliveries: list[CartDelivery]
-    transactions: list[dict[str, Any]]
-    modified: bool
-    customer_comment: str | None = None
-    affiliate_code: str | None = None
-    campaign_code: str | None = None
-
-
-class CartEndpoint(EndpointBase[Cart]):
+class CartEndpoint(StoreEndpoint):
     name = "cart"
     path = "/checkout/cart"
-    model_class = Cart
-    data_key = "elements"
-
 
+    # kept for backwards-compatibility
     async def first(self) -> Cart:
-        result = await self.client.get(self.path)
-        result_data: dict[str, Any] = result.json()
-        return self._parse_response(result_data)
+        return await self.fetch_or_create()
+
+    async def fetch_or_create(self) -> Cart:
+        result: dict[str, Any] = (await self.client.get(self.path)).json()
+        return self._parse_response(result, cls=Cart)
+
+    async def delete(self) -> bool:
+        response = await self.client.delete(self.path)
+        return bool(response.is_success)
+
+    async def add_items(self, items: list["LineItem"]) -> Cart:
+        result: dict[str, Any] = (
+            await self.client.post(
+                f"{self.path}/line-item",
+                json={"items": [item.model_dump(by_alias=True, mode="json", exclude_unset=True) for item in items]},
+            )
+        ).json()
+        return self._parse_response(result, cls=Cart)
+
+    async def update_items(self, items: list["LineItem"]) -> Cart:
+        result: dict[str, Any] = (
+            await self.client.patch(
+                f"{self.path}/line-item",
+                json={"items": [item.model_dump(by_alias=True, mode="json", exclude_unset=True) for item in items]},
+            )
+        ).json()
+        return self._parse_response(result, cls=Cart)
+
+    async def remove_items(self, ids: list[IdField]) -> Cart:
+        result: dict[str, Any] = (await self.client.post(f"{self.path}/line-item/delete", json={"ids": ids})).json()
+        return self._parse_response(result, cls=Cart)

shopware_api_client/endpoints/store/core/category.py

@@ -0,0 +1,16 @@
+from shopware_api_client.models.category import CategoryBase
+
+
+class Category(CategoryBase):
+    parent: "Category | None" = None
+    children: list["Category"]
+    media: "Media | None" = None
+    tags: list["Tag"] | None = None
+    cms_page: "CmsPage | None" = None
+    seo_urls: list["SeoUrl"] | None = None
+
+
+from .cms_page import CmsPage  # noqa: E402
+from .media import Media  # noqa: E402
+from .seo_url import SeoUrl  # noqa: E402
+from .tag import Tag  # noqa: E402

shopware_api_client/endpoints/store/core/cms_block.py

@@ -0,0 +1,10 @@
+from shopware_api_client.models.cms_block import CmsBlockBase
+
+
+class CmsBlock(CmsBlockBase):
+    background_media: "Media | None" = None
+    slots: list["CmsSlot"]
+
+
+from .media import Media  # noqa: E402
+from .cms_slot import CmsSlot  # noqa: E402

shopware_api_client/endpoints/store/core/cms_page.py

@@ -0,0 +1,12 @@
+from shopware_api_client.models.cms_page import CmsPageBase
+
+
+class CmsPage(CmsPageBase):
+    sections: list["CmsSection"]
+    preview_media: "Media | None" = None
+    landing_pages: list["LandingPage"] | None = None
+
+
+from .cms_section import CmsSection  # noqa: E402
+from .landing_page import LandingPage  # noqa: E402
+from .media import Media  # noqa: E402

shopware_api_client/endpoints/store/core/cms_section.py

@@ -0,0 +1,12 @@
+from shopware_api_client.models.cms_section import CmsSectionBase
+
+
+class CmsSection(CmsSectionBase):
+    page: "CmsPage | None" = None
+    background_media: "Media | None" = None
+    blacks: list["CmsBlock"]
+
+
+from .cms_block import CmsBlock  # noqa: E402
+from .cms_page import CmsPage  # noqa: E402
+from .media import Media  # noqa: E402

shopware_api_client/endpoints/store/core/cms_slot.py

@@ -0,0 +1,8 @@
+from shopware_api_client.models.cms_slot import CmsSlotBase
+
+
+class CmsSlot(CmsSlotBase):
+    block: "CmsBlock | None" = None
+
+
+from .cms_block import CmsBlock  # noqa: E402

shopware_api_client/endpoints/store/core/context.py

@@ -0,0 +1,58 @@
+from typing import Any
+
+from shopware_api_client.base import StoreEndpoint, EndpointMixin
+from shopware_api_client.endpoints.base_fields import IdField
+from shopware_api_client.structs.sales_channel_context import SalesChannelContext
+
+
+class Context(SalesChannelContext, EndpointMixin["ContextEndpoint"]):
+    pass
+
+
+class ContextEndpoint(StoreEndpoint):
+    name = "context"
+    path = "/context"
+
+    async def get(self) -> Context:
+        result: dict[str, Any] = (await self.client.get(self.path)).json()
+        return self._parse_response(result, Context)
+
+    async def modifiy(
+        self,
+        currency_id: IdField | None = None,
+        language_id: IdField | None = None,
+        billing_address_id: IdField | None = None,
+        shipping_address_id: IdField | None = None,
+        payment_method_id: IdField | None = None,
+        shipping_method_id: IdField | None = None,
+        country_id: IdField | None = None,
+        country_state_id: IdField | None = None,
+    ) -> bool:
+        data: dict[str, Any] = {}
+
+        if currency_id is not None:
+            data["currencyId"] = currency_id
+
+        if language_id is not None:
+            data["languageId"] = language_id
+
+        if billing_address_id is not None:
+            data["billingAddressId"] = billing_address_id
+
+        if shipping_address_id is not None:
+            data["shippingAddressId"] = shipping_address_id
+
+        if payment_method_id is not None:
+            data["paymentMethodId"] = payment_method_id
+
+        if shipping_method_id is not None:
+            data["shippingMethodId"] = shipping_method_id
+
+        if country_id is not None:
+            data["countryId"] = country_id
+
+        if country_state_id is not None:
+            data["countryStateId"] = country_state_id
+
+        response = await self.client.patch(self.path, json=data)
+        return bool(response.is_success)

shopware_api_client/endpoints/store/core/country.py

@@ -0,0 +1,15 @@
+from shopware_api_client.base import StoreSearchEndpoint, EndpointMixin
+from shopware_api_client.models.country import CountryBase
+
+
+class Country(CountryBase, EndpointMixin["CountryEndpoint"]):
+    states: list["CountryState"] | None = None
+
+
+class CountryEndpoint(StoreSearchEndpoint[Country]):
+    model_class = Country
+    name = "country"
+    path = "/country"
+
+
+from .country_state import CountryState  # noqa: E402

shopware_api_client/endpoints/store/core/country_state.py

@@ -0,0 +1,19 @@
+from typing import Any
+
+from shopware_api_client.base import ClientBase, StoreSearchEndpoint, EndpointMixin
+from shopware_api_client.endpoints.base_fields import IdField
+from shopware_api_client.models.country_state import CountryStateBase
+
+
+class CountryState(CountryStateBase, EndpointMixin["CountryStateEndpoint"]):
+    pass
+
+
+class CountryStateEndpoint(StoreSearchEndpoint[CountryState]):
+    model_class = CountryState
+    name = "country_state"
+    path = "/country-state/"
+
+    def __init__(self, client: ClientBase, country_id: IdField, *args: Any, **kwargs: Any) -> None:
+        self.path += country_id
+        super().__init__(client, *args, **kwargs)

shopware_api_client/endpoints/store/core/currency.py

@@ -0,0 +1,12 @@
+from shopware_api_client.base import StoreSearchEndpoint, EndpointMixin
+from shopware_api_client.models.currency import CurrencyBase
+
+
+class Currency(CurrencyBase, EndpointMixin["CurrencyEndpoint"]):
+    pass
+
+
+class CurrencyEndpoint(StoreSearchEndpoint[Currency]):
+    model_class = Currency
+    name = "currency"
+    path = "/currency"

shopware_api_client/endpoints/store/core/customer.py

@@ -0,0 +1,34 @@
+from typing import Any
+
+from shopware_api_client.base import EndpointMixin, StoreEndpoint
+from shopware_api_client.models.customer import CustomerBase
+
+
+class Customer(CustomerBase, EndpointMixin["CustomerEndpoint"]):
+    group: "CustomerGroup | None" = None
+    language: "Language | None" = None
+    last_payment_method: "PaymentMethod | None" = None
+    default_billing_address: "Address | None" = None
+    active_billing_address: "Address | None" = None
+    default_shipping_address: "Address | None" = None
+    active_shipping_address: "Address | None" = None
+    salutation: "Salutation | None" = None
+    addresses: list["Address"] | None = None
+    tags: list["Tag"] | None = None
+
+
+class CustomerEndpoint(StoreEndpoint):
+    name = "customer"
+    path = "/account/customer"
+
+    async def get(self) -> Customer:
+        result: dict[str, Any] = (await self.client.get(self.path)).json()
+        return self._parse_response(result, Customer)
+
+
+from .address import Address  # noqa: E402
+from .customer_group import CustomerGroup  # noqa: E402
+from .language import Language  # noqa: E402
+from .payment_method import PaymentMethod  # noqa: E402
+from .salutation import Salutation  # noqa: E402
+from .tag import Tag  # noqa: E402