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

shopware_api_client/cache.py

@@ -0,0 +1,157 @@
+import json
+from abc import ABC, abstractmethod
+from collections import OrderedDict
+from time import time
+from typing import Any, Awaitable, NamedTuple, cast
+
+try:
+    from redis.asyncio import Redis
+
+    _has_redis = True
+except ModuleNotFoundError:
+    _has_redis = False
+
+
+class CacheBase(ABC):
+    @abstractmethod
+    async def get(self, key: str) -> Any | None: ...
+
+    @abstractmethod
+    async def get_and_decrement(self, key: str) -> int | None: ...
+
+    @abstractmethod
+    async def has_lock(self, key: str, ttl: int) -> bool: ...
+
+    @abstractmethod
+    async def set(self, key: str, value: Any, ttl: int | None = None) -> None: ...
+
+    @abstractmethod
+    async def delete(self, key: str) -> None: ...
+
+    @staticmethod
+    def _json_encode(key: str, value: Any) -> str:
+        try:
+            return json.dumps(value)
+        except (TypeError, ValueError) as e:
+            raise ValueError(f"Value {value!r} for cache key {key!r} must be JSON-serializable: {e}") from e
+
+    @staticmethod
+    def _json_decode(raw_value: Any) -> Any | None:
+        if raw_value is None:
+            return None
+
+        try:
+            return json.loads(raw_value)
+        except json.JSONDecodeError:
+            # If write was broken, mimic missing key
+            return None
+
+
+class RedisCache(CacheBase):
+    _DECR_IF_EXISTS = """
+        if redis.call('EXISTS', KEYS[1]) == 1 then
+            return redis.call('DECR', KEYS[1])
+        else
+            return nil
+        end
+    """
+
+    def __init__(self, redis_client: "Redis") -> None:
+        if not _has_redis:
+            raise RuntimeError("Redis needs to be installed to use it as a cache.")
+
+        self.client = redis_client
+
+    async def get(self, key: str) -> Any | None:
+        value = await self.client.get(key)
+        return self._json_decode(value)
+
+    async def get_and_decrement(self, key: str) -> int | None:
+        return_value = await cast(Awaitable[int | None], self.client.eval(self._DECR_IF_EXISTS, 1, key))
+        return None if return_value is None else return_value + 1
+
+    async def has_lock(self, key: str, ttl: int) -> bool:
+        return await self.client.set(key, 1, ex=ttl, nx=True) or False
+
+    async def set(self, key: str, value: Any, ttl: int | None = None) -> None:
+        await self.client.set(name=key, value=self._json_encode(key, value), ex=ttl)
+
+    async def delete(self, key: str) -> None:
+        await self.client.delete(key)
+
+
+class DictCache(CacheBase):
+    class CacheValue(NamedTuple):
+        value: Any
+        expire_at: int | None
+
+    def __init__(self, cleanup_cycle_seconds: int) -> None:
+        self._cache: OrderedDict[str, DictCache.CacheValue] = OrderedDict()
+        self.cleanup_cycle_seconds = cleanup_cycle_seconds
+        self.next_cleanup: int = 0
+
+    async def get(self, key: str) -> Any | None:
+        self._cleanup_by_expiry()
+        entry = self._cache.get(key)
+
+        return self._json_decode(entry and entry.value)
+
+    async def get_and_decrement(self, key: str) -> int | None:
+        self._cleanup_by_expiry()
+        entry = self._cache.get(key)
+        if entry is None:
+            return None
+
+        decoded_value = self._json_decode(entry.value)
+        if not isinstance(decoded_value, int):
+            raise ValueError(f"Trying to decrement key {key!r}, but value {decoded_value!r} is not an int")
+
+        new_value = decoded_value - 1
+        self._cache[key] = DictCache.CacheValue(self._json_encode(key, new_value), entry.expire_at)
+
+        return decoded_value
+
+    async def has_lock(self, key: str, ttl: int) -> bool:
+        self._cleanup_by_expiry(False)
+        entry = self._cache.get(key)
+        if unlocked := entry is None:
+            self._cache[key] = DictCache.CacheValue(True, self.get_expiry(ttl))
+
+        return unlocked
+
+    async def set(self, key: str, value: Any, ttl: int | None = None) -> None:
+        self._cleanup_by_expiry()
+        cache_value = self._json_encode(key, value)
+
+        self._cache[key] = DictCache.CacheValue(cache_value, self.get_expiry(ttl))
+
+    async def delete(self, key: str) -> None:
+        self._cleanup_by_expiry()
+        self._cache.pop(key, None)
+
+    def get_expiry(self, ttl: int | None) -> int | None:
+        return int(time()) + ttl if ttl is not None else None
+
+    def _cleanup_by_expiry(self, do_wait: bool = True) -> None:
+        now = int(time())
+
+        if now < self.next_cleanup and do_wait:
+            return
+
+        initial_size = len(self._cache)
+        for _ in range(initial_size):
+            if not self._cache:
+                break
+
+            first_key, first_value = next(iter(self._cache.items()))
+
+            if first_value.expire_at is None:
+                self._cache.move_to_end(first_key)
+                continue
+
+            if first_value.expire_at > now:
+                break
+
+            self._cache.popitem(last=False)
+
+        self.next_cleanup = now + self.cleanup_cycle_seconds

shopware_api_client/client.py

@@ -19,7 +19,7 @@ class AdminClient(ClientBase, AdminEndpoints):
         self._client: httpx.AsyncClient | None = None
         self.init_endpoints(self)
 
-    def _get_client(self) -> httpx.AsyncClient:
+    def _get_http_client(self) -> httpx.AsyncClient:
         if self._client is None:
             self._client = httpx.AsyncClient(
                 event_hooks={"request": [self.log_request], "response": [self.log_response]}
@@ -180,7 +180,7 @@ class StoreClient(ClientBase, StoreEndpoints):
         self._client: httpx.AsyncClient | None = None
         self.init_endpoints(self)
 
-    def _get_client(self) -> httpx.AsyncClient:
+    def _get_http_client(self) -> httpx.AsyncClient:
         if self._client is None:
             self._client = httpx.AsyncClient(
                 event_hooks={"request": [self.log_request], "response": [self.log_response]},

shopware_api_client/config.py

@@ -14,6 +14,7 @@ class AdminConfig(ConfigBase):
         client_secret: str | None = None,
         grant_type: str = "client_credentials",
         extra: dict[str, Any] | None = None,
+        **kwargs: Any,
     ) -> None:
         match grant_type:
             case "client_credentials":
@@ -27,7 +28,7 @@ class AdminConfig(ConfigBase):
             case _:
                 raise SWAPIConfigException("Invalid 'grant_type'. Must be one of: 'client_credentials', 'password'")
 
-        super().__init__(url=url)
+        super().__init__(url=url, **kwargs)
         self.username = username
         self.password = password
         self.client_id = client_id
@@ -37,7 +38,7 @@ class AdminConfig(ConfigBase):
 
 
 class StoreConfig(ConfigBase):
-    def __init__(self, url: str, access_key: str, context_token: str | None = None):
-        super().__init__(url=url)
+    def __init__(self, url: str, access_key: str, context_token: str | None = None, **kwargs: Any):
+        super().__init__(url=url, **kwargs)
         self.access_key = access_key
         self.context_token = context_token

shopware_api_client/endpoints/admin/__init__.py

@@ -1,9 +1,16 @@
 from typing import TYPE_CHECKING
 
+from ...base import AdminModel
+
 if TYPE_CHECKING:
     from ...client import AdminClient
 
 from .commercial.b2b_components_role import B2bComponentsRole, B2bComponentsRoleEndpoint
+from .commercial.b2b_components_shopping_list import B2bComponentsShoppingList, B2bComponentsShoppingListEndpoint
+from .commercial.b2b_components_shopping_list_line_item import (
+    B2bComponentsShoppingListLineItem,
+    B2bComponentsShoppingListLineItemEndpoint,
+)
 from .commercial.b2b_employee import B2bEmployee, B2bEmployeeEndpoint
 from .commercial.dynamic_access import DynamicAccess, DynamicAccessEndpoint
 from .core.acl_role import AclRole, AclRoleEndpoint
@@ -91,6 +98,7 @@ from .core.sales_channel_domain import SalesChannelDomain, SalesChannelDomainEnd
 from .core.salutation import Salutation, SalutationEndpoint
 from .core.seo_url import SeoUrl, SeoUrlEndpoint
 from .core.shipping_method import ShippingMethod, ShippingMethodEndpoint
+from .core.shipping_method_price import ShippingMethodPrice, ShippingMethodPriceEndpoint
 from .core.state_machine import StateMachine, StateMachineEndpoint
 from .core.state_machine_history import StateMachineHistory, StateMachineHistoryEndpoint
 from .core.state_machine_state import StateMachineState, StateMachineStateEndpoint
@@ -111,6 +119,8 @@ __all__ = [
     "AdminEndpoints",
     "B2bComponentsRole",
     "B2bEmployee",
+    "B2bComponentsShoppingList",
+    "B2bComponentsShoppingListLineItem",
     "ApiInfo",
     "App",
     "AppScriptCondition",
@@ -187,6 +197,7 @@ __all__ = [
     "Salutation",
     "SeoUrl",
     "ShippingMethod",
+    "ShippingMethodPrice",
     "StateMachine",
     "StateMachineHistory",
     "StateMachineState",
@@ -211,11 +222,11 @@ class AdminEndpoints:
 
         from pydantic import AwareDatetime, create_model
 
-        from ...base import ApiModelBase, EndpointBase
+        from ...base import AdminEndpoint
         from ..base_fields import IdField
 
         async for custom_entity in self.custom_entity.iter():
-            assert(isinstance(custom_entity, CustomEntity))
+            assert isinstance(custom_entity, CustomEntity)
             fields: dict[str, Any] = {}
 
             for field in custom_entity.fields:
@@ -255,9 +266,11 @@ class AdminEndpoints:
 
             fields["_identifier"] = (str, custom_entity.name)
 
-            ce_model: type[ApiModelBase[Any]] = create_model(custom_entity.name, **fields, __base__=ApiModelBase[EndpointBase])
+            ce_model: type[AdminModel[Any]] = create_model(
+                custom_entity.name, **fields, __base__=AdminModel[AdminEndpoint]
+            )
 
-            ce_endpoint = new_class(f"{custom_entity.name}Endpoint", (EndpointBase[ApiModelBase],))
+            ce_endpoint = new_class(f"{custom_entity.name}Endpoint", (AdminEndpoint[AdminModel],))
             ce_endpoint.name = custom_entity.name  # type: ignore
             ce_endpoint.path = f"/{custom_entity.name.replace('_', '-')}"  # type: ignore
             ce_endpoint.model_class = ce_model  # type: ignore
@@ -269,6 +282,8 @@ class AdminEndpoints:
         self.b2b_employee = B2bEmployeeEndpoint(client)
         self.b2b_components_role = B2bComponentsRoleEndpoint(client)
         self.dynamic_access = DynamicAccessEndpoint(client)
+        self.b2b_components_shopping_list = B2bComponentsShoppingListEndpoint(client)
+        self.b2b_components_shopping_list_line_item = B2bComponentsShoppingListLineItemEndpoint(client)
 
         # Core
         self.acl_role = AclRoleEndpoint(client)
@@ -347,6 +362,7 @@ class AdminEndpoints:
         self.salutation = SalutationEndpoint(client)
         self.seo_url = SeoUrlEndpoint(client)
         self.shipping_method = ShippingMethodEndpoint(client)
+        self.shipping_method_price = ShippingMethodPriceEndpoint(client)
         self.state_machine = StateMachineEndpoint(client)
         self.state_machine_history = StateMachineHistoryEndpoint(client)
         self.state_machine_state = StateMachineStateEndpoint(client)

shopware_api_client/endpoints/admin/commercial/b2b_components_role.py

@@ -1,29 +1,14 @@
-from typing import Any
+from shopware_api_client.base import AdminEndpoint, AdminModel
+from shopware_api_client.endpoints.relations import ForeignRelation, ManyRelation
+from shopware_api_client.models.b2b_components_role import B2bComponentsRoleBase
 
-from ....base import ApiModelBase, EndpointBase, EndpointClass
-from ...base_fields import IdField
-from ...relations import ForeignRelation, ManyRelation
 
-
-class B2bComponentsRoleBase(ApiModelBase[EndpointClass]):
-    _identifier: str = "b2b_components_role"
-
-    business_partner_customer_id: IdField | None = None
-    name: str
-    permissions: dict[str, Any] | None = None
-    custom_fields: dict[str, Any] | None = None
-
-
-class B2bComponentsRoleRelations:
+class B2bComponentsRole(B2bComponentsRoleBase, AdminModel["B2bComponentsRoleEndpoint"]):
     employees: ManyRelation["B2bEmployee"]
     business_partner_customer: ForeignRelation["Customer"]
 
 
-class B2bComponentsRole(B2bComponentsRoleBase["B2bComponentsRoleEndpoint"], B2bComponentsRoleRelations):
-    pass
-
-
-class B2bComponentsRoleEndpoint(EndpointBase[B2bComponentsRole]):
+class B2bComponentsRoleEndpoint(AdminEndpoint[B2bComponentsRole]):
     name = "b2b_components_role"
     path = "/b2b-components-role"
     model_class = B2bComponentsRole

shopware_api_client/endpoints/admin/commercial/b2b_components_shopping_list.py

@@ -0,0 +1,22 @@
+from shopware_api_client.base import AdminModel, AdminEndpoint
+from shopware_api_client.endpoints.relations import ForeignRelation, ManyRelation
+from shopware_api_client.models.b2b_components_shopping_list import B2bComponentsShoppingListBase
+
+
+class B2bComponentsShoppingList(B2bComponentsShoppingListBase, AdminModel["B2bComponentsShoppingListEndpoint"]):
+    sales_channel: ForeignRelation["SalesChannel"]
+    line_items: ManyRelation["B2bComponentsShoppingListLineItem"]
+    customer: ForeignRelation["Customer"]
+    employee: ForeignRelation["B2bEmployee"]
+
+
+class B2bComponentsShoppingListEndpoint(AdminEndpoint[B2bComponentsShoppingList]):
+    name = "b2b_components_shopping_list"
+    path = "/b2b-components-shopping-list"
+    model_class = B2bComponentsShoppingList
+
+
+from ..core.customer import Customer  # noqa: E402
+from ..core.sales_channel import SalesChannel  # noqa: E402
+from .b2b_components_shopping_list_line_item import B2bComponentsShoppingListLineItem  # noqa: E402
+from .b2b_employee import B2bEmployee  # noqa: E402

shopware_api_client/endpoints/admin/commercial/b2b_components_shopping_list_line_item.py

@@ -0,0 +1,20 @@
+from shopware_api_client.base import AdminModel, AdminEndpoint
+from shopware_api_client.endpoints.relations import ForeignRelation
+from shopware_api_client.models.b2b_components_shopping_list_line_item import B2bComponentsShoppingListLineItemBase
+
+
+class B2bComponentsShoppingListLineItem(
+    B2bComponentsShoppingListLineItemBase, AdminModel["B2bComponentsShoppingListLineItemEndpoint"]
+):
+    shopping_list: ForeignRelation["B2bComponentsShoppingList"]
+    product: ForeignRelation["Product"]
+
+
+class B2bComponentsShoppingListLineItemEndpoint(AdminEndpoint[B2bComponentsShoppingListLineItem]):
+    name = "b2b_components_shopping_list_line_item"
+    path = "/b2b-components-shopping-list-line-item"
+    model_class = B2bComponentsShoppingListLineItem
+
+
+from ..core.product import Product  # noqa: E402
+from .b2b_components_shopping_list import B2bComponentsShoppingList  # noqa: E402

shopware_api_client/endpoints/admin/commercial/b2b_employee.py

@@ -1,37 +1,15 @@
-from typing import Any
+from shopware_api_client.base import AdminEndpoint, AdminModel
+from shopware_api_client.endpoints.relations import ForeignRelation
+from shopware_api_client.models.b2b_employee import B2bEmployeeBase
 
-from pydantic import AwareDatetime
 
-from ....base import ApiModelBase, EndpointBase, EndpointClass
-from ...base_fields import IdField
-from ...relations import ForeignRelation
-
-
-class B2bEmployeeBase(ApiModelBase[EndpointClass]):
-    _identifier: str = "b2b_employee"
-
-    business_partner_customer_id: IdField | None = None
-    role_id: IdField | None = None
-    language_id: IdField
-    active: bool | None = None
-    first_name: str
-    last_name: str
-    email: str
-    recovery_time: AwareDatetime | None = None
-    custom_fields: dict[str, Any] | None = None
-
-
-class B2bEmployeeRelations:
+class B2bEmployee(B2bEmployeeBase, AdminModel["B2bEmployeeEndpoint"]):
     business_partner_customer: ForeignRelation["Customer"]
     role: ForeignRelation["B2bComponentsRole"]
     language: ForeignRelation["Language"]
 
 
-class B2bEmployee(B2bEmployeeBase["B2bEmployeeEndpoint"], B2bEmployeeRelations):
-    pass
-
-
-class B2bEmployeeEndpoint(EndpointBase[B2bEmployee]):
+class B2bEmployeeEndpoint(AdminEndpoint[B2bEmployee]):
     name = "b2b_employee"
     path = "/b2b-employee"
     model_class = B2bEmployee

shopware_api_client/endpoints/admin/commercial/dynamic_access.py

@@ -1,28 +1,18 @@
+from shopware_api_client.base import AdminEndpoint, AdminModel
+from shopware_api_client.endpoints.relations import ForeignRelation
+from shopware_api_client.models.dynamic_access import DynamicAccessBase
 
-from shopware_api_client.endpoints.admin.core.product import Product
-from shopware_api_client.endpoints.admin.core.rule import Rule
 
-from ....base import ApiModelBase, EndpointBase, EndpointClass
-from ...base_fields import IdField
-from ...relations import ForeignRelation
-
-
-class DynamicAccessBase(ApiModelBase[EndpointClass]):
-    _identifier: str = "dynamic_access"
-
-    product_id: IdField
-    rule_id: IdField
-
-class DynamicAccessRelations:
+class DynamicAccess(DynamicAccessBase, AdminModel["DynamicAccessEndpoint"]):
     product: ForeignRelation["Product"]
     rule: ForeignRelation["Rule"]
 
 
-class DynamicAccess(DynamicAccessBase["DynamicAccessEndpoint"], DynamicAccessRelations):
-    pass
-
-
-class DynamicAccessEndpoint(EndpointBase[DynamicAccess]):
+class DynamicAccessEndpoint(AdminEndpoint[DynamicAccess]):
     name = "swag_dynamic_access_product_rule"
     path = "/swag-dynamic-access-product-rule"
     model_class = DynamicAccess
+
+
+from ..core.product import Product  # noqa: E402
+from ..core.rule import Rule  # noqa: E402

shopware_api_client/endpoints/admin/core/acl_role.py

@@ -1,29 +1,15 @@
-from pydantic import AwareDatetime
+from shopware_api_client.base import AdminEndpoint, AdminModel
+from shopware_api_client.endpoints.relations import ForeignRelation, ManyRelation
+from shopware_api_client.models.acl_role import AclRoleBase
 
-from ....base import ApiModelBase, EndpointBase, EndpointClass
-from ...relations import ForeignRelation, ManyRelation
 
-
-class AclRoleBase(ApiModelBase[EndpointClass]):
-    _identifier = "acl_role"
-
-    name: str
-    description: str | None = None
-    privileges: list[str]
-    deleted_at: AwareDatetime | None = None
-
-
-class AclRoleRelations:
+class AclRole(AclRoleBase, AdminModel["AclRoleEndpoint"]):
     users: ManyRelation["User"]
     app: ForeignRelation["App"]
     integrations: ManyRelation["Integration"]
 
 
-class AclRole(AclRoleBase["AclRoleEndpoint"], AclRoleRelations):
-    pass
-
-
-class AclRoleEndpoint(EndpointBase[AclRole]):
+class AclRoleEndpoint(AdminEndpoint[AclRole]):
     name = "acl_role"
     path = "/acl-role"
     model_class = AclRole

shopware_api_client/endpoints/admin/core/api_info.py

@@ -3,10 +3,9 @@ from typing import Any
 from pydantic import BaseModel
 from pydantic.main import IncEx
 
+from shopware_api_client.base import AdminEndpoint, AdminModel
 from shopware_api_client.exceptions import SWAPIMethodNotAvailable
 
-from ....base import ApiModelBase, EndpointBase, EndpointClass
-
 
 class Bundle(BaseModel):
     css: list[str]
@@ -25,7 +24,7 @@ class AppBundle(BaseModel):
     name: str
 
 
-class ApiInfoBase(ApiModelBase[EndpointClass]):
+class ApiInfo(AdminModel["ApiInfoEndpoint"]):
     _identifier = "api_info"
 
     version: str
@@ -36,25 +35,23 @@ class ApiInfoBase(ApiModelBase[EndpointClass]):
     license_toggles: dict[str, bool] | None = None
 
 
-class ApiInfo(ApiInfoBase["ApiInfoEndpoint"]):
-    pass
-
-
-class ApiInfoEndpoint(EndpointBase[ApiInfo]):
+class ApiInfoEndpoint(AdminEndpoint[ApiInfo]):
     name = "adminWorker"
     path = "/_info/config"
     model_class = ApiInfo
 
     async def delete(self, pk: str) -> bool:
         raise SWAPIMethodNotAvailable()
-    
+
     async def get(self, pk: str) -> ApiInfo | dict[str, Any]:
         raise SWAPIMethodNotAvailable()
 
     async def create(self, obj: ApiInfo | dict[str, Any]) -> ApiInfo | dict[str, Any] | None:
         raise SWAPIMethodNotAvailable()
 
-    async def update(self, pk: str, obj: ApiInfo | dict[str, Any], update_fields: IncEx | None = None) -> ApiInfo | dict[str, Any] | None:
+    async def update(
+        self, pk: str, obj: ApiInfo | dict[str, Any], update_fields: IncEx | None = None
+    ) -> ApiInfo | dict[str, Any] | None:
         raise SWAPIMethodNotAvailable()
 
     async def bulk_upsert(
@@ -62,5 +59,7 @@ class ApiInfoEndpoint(EndpointBase[ApiInfo]):
     ) -> dict[str, Any]:
         raise SWAPIMethodNotAvailable()
 
-    async def bulk_delete(self, objs: list[ApiInfo] | list[dict[str, Any]], fail_silently: bool = False, **request_kwargs: Any) -> dict[str, Any]:
-        raise SWAPIMethodNotAvailable()
+    async def bulk_delete(
+        self, objs: list[ApiInfo] | list[dict[str, Any]], fail_silently: bool = False, **request_kwargs: Any
+    ) -> dict[str, Any]:
+        raise SWAPIMethodNotAvailable()

shopware_api_client/endpoints/admin/core/app.py

@@ -1,52 +1,15 @@
-from typing import Any
+from shopware_api_client.base import AdminEndpoint, AdminModel
+from shopware_api_client.endpoints.relations import ForeignRelation, ManyRelation
+from shopware_api_client.models.app import AppBase
 
-from pydantic import Field
 
-from ....base import ApiModelBase, EndpointBase, EndpointClass
-from ...base_fields import IdField
-from ...relations import ForeignRelation, ManyRelation
-
-
-class AppBase(ApiModelBase[EndpointClass]):
-    _identifier = "app"
-
-    name: str
-    path: str
-    author: str | None = None
-    copyright: str | None = None
-    license: str | None = None
-    active: bool
-    configurable: bool
-    privacy: str | None = None
-    version: str
-    icon: str | None = Field(None, description="Runtime field, cannot be used as part of the criteria.", exclude=True)
-    modules: list[dict[str, Any]] | None = None
-    main_module: dict[str, Any] | None = None
-    cookies: list[dict[str, Any]] | None = None
-    allow_disable: bool
-    base_app_url: str | None = None
-    allowed_hosts: list[str] | None = None
-    template_load_priority: int | None = None
-    label: str
-    description: str | None = None
-    privacy_policy_extensions: str | None = None
-    custom_fields: dict[str, Any] | None = None
-    integration_id: IdField
-    acl_role_id: IdField
-    translated: dict[str, Any] | None = None
-
-
-class AppRelations:
+class App(AppBase, AdminModel["AppEndpoint"]):
     app: ForeignRelation["App"]
     acl_roles: ManyRelation["AclRole"]
     integrations: ManyRelation["Integration"]
 
 
-class App(AppBase["AppEndpoint"], AppRelations):
-    pass
-
-
-class AppEndpoint(EndpointBase[App]):
+class AppEndpoint(AdminEndpoint[App]):
     name = "app"
     path = "/app"
     model_class = App

shopware_api_client/endpoints/admin/core/app_script_condition.py

@@ -1,33 +1,14 @@
-from typing import Any
+from shopware_api_client.base import AdminEndpoint, AdminModel
+from shopware_api_client.endpoints.relations import ForeignRelation, ManyRelation
+from shopware_api_client.models.app_script_condition import AppScriptConditionBase
 
-from ....base import ApiModelBase, EndpointBase, EndpointClass
-from ...base_fields import IdField
-from ...relations import ForeignRelation, ManyRelation
 
-
-class AppScriptConditionBase(ApiModelBase[EndpointClass]):
-    _identifier = "app_script_condition"
-
-    identifier: str
-    name: str
-    active: bool
-    group: str | None = None
-    script: str | None = None
-    config: list[dict[str, Any]] | None = None
-    app_id: IdField
-    translated: dict[str, Any] | None = None
-
-
-class AppScriptConditionRelations:
+class AppScriptCondition(AppScriptConditionBase, AdminModel["AppScriptConditionEndpoint"]):
     app: ForeignRelation["App"]
     rule_conditions: ManyRelation["RuleCondition"]
 
 
-class AppScriptCondition(AppScriptConditionBase["AppScriptConditionEndpoint"], AppScriptConditionRelations):
-    pass
-
-
-class AppScriptConditionEndpoint(EndpointBase[AppScriptCondition]):
+class AppScriptConditionEndpoint(AdminEndpoint[AppScriptCondition]):
     name = "app_script_condition"
     path = "/app-script-condition"
     model_class = AppScriptCondition