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

shopware_api_client/endpoints/admin/core/payment_method.py

@@ -1,52 +1,9 @@
-from typing import Any
+from shopware_api_client.base import AdminModel, AdminEndpoint
+from shopware_api_client.endpoints.relations import ForeignRelation, ManyRelation
+from shopware_api_client.models.payment_method import PaymentMethodBase
 
-from pydantic import Field
 
-from ....base import ApiModelBase, EndpointBase, EndpointClass
-from ...base_fields import IdField
-from ...relations import ForeignRelation, ManyRelation
-
-_FILED_DESCRIPTION = "Runtime field, cannot be used as part of the criteria."
-
-
-class PaymentMethodBase(ApiModelBase[EndpointClass]):
-    _identifier: str = "payment_method"
-
-    plugin_id: IdField | None = None
-    handler_identifier: str | None = None
-    name: str
-    distinguishable_name: str | None = Field(default=None, exclude=True)
-    description: str | None = None
-    position: int | None = None
-    active: bool | None = None
-    after_order_enabled: bool | None = None
-    custom_fields: dict[str, Any] | None = None
-    availability_rule_id: IdField | None = None
-    media_id: IdField | None = None
-    formatted_handler_identifier: str | None = Field(
-        None, description=_FILED_DESCRIPTION, exclude=True
-    )
-    synchronous: bool | None = Field(
-        None, description=_FILED_DESCRIPTION, exclude=True
-    )
-    asynchronous: bool | None = Field(
-        None, description=_FILED_DESCRIPTION, exclude=True
-    )
-    prepared: bool | None = Field(
-        None, description=_FILED_DESCRIPTION, exclude=True
-    )
-    refundable: bool | None = Field(
-        None, description=_FILED_DESCRIPTION, exclude=True
-    )
-    recurring: bool | None = Field(
-        None, description=_FILED_DESCRIPTION, exclude=True
-    )
-    short_name: str | None = Field(None, description=_FILED_DESCRIPTION)
-    technical_name: str | None = Field(default=None, exclude=True)
-    translated: dict[str, Any] | None = None
-
-
-class PaymentMethodRelations:
+class PaymentMethod(PaymentMethodBase, AdminModel["PaymentMethodEndpoint"]):
     media: ForeignRelation["Media"]
     availability_rule: ForeignRelation["Rule"]
     sales_channel_default_assignments: ManyRelation["SalesChannel"]
@@ -60,11 +17,7 @@ class PaymentMethodRelations:
     """
 
 
-class PaymentMethod(PaymentMethodBase["PaymentMethodEndpoint"], PaymentMethodRelations):
-    pass
-
-
-class PaymentMethodEndpoint(EndpointBase[PaymentMethod]):
+class PaymentMethodEndpoint(AdminEndpoint[PaymentMethod]):
     name = "payment_method"
     path = "/payment-method"
     model_class = PaymentMethod

shopware_api_client/endpoints/admin/core/product.py

@@ -1,103 +1,40 @@
 from typing import Any
 
-from pydantic import AwareDatetime, Field, field_validator
+from pydantic import field_validator
 from pydantic_core.core_schema import FieldValidationInfo
 
-from ....base import ApiModelBase, EndpointBase, EndpointClass
+from shopware_api_client.base import AdminModel, AdminEndpoint
 from ...base_fields import IdField
-from ...relations import ForeignRelation, ManyRelation
-
-
-class ProductBase(ApiModelBase[EndpointClass]):
-    _identifier: str = "product"
-
-    version_id: IdField | None = None
-    parent_id: IdField | None = None
-    parent_version_id: IdField | None = None
-    manufacturer_id: IdField | None = None
-    product_manufacturer_version_id: IdField | None = None
-    unit_id: IdField | None = None
-    tax_id: IdField | None = None
-    cover_id: IdField | None = None
-    product_media_version_id: IdField | None = None
-    delivery_time_id: IdField | None = None
-    feature_set_id: IdField | None = None
-    canonical_product_id: IdField | None = None
-    cms_page_id: IdField | None = None
-    cms_page_version_id: IdField | None = None
-    price: list[dict[str, Any]] | None = None
-    product_number: str
-    restock_time: int | None = None
-    auto_increment: int | None = Field(default=None, exclude=True)
-    active: bool | None = None
-    available: bool | None = Field(default=None, exclude=True)
-    is_closeout: bool | None = None
-    variation: list[str] | None = None
-    display_group: str | None = Field(default=None, exclude=True)
-    variant_listing_config: dict[str, Any] | None = None
-    variant_restrictions: dict[str, Any] | None = None
-    manufacturer_number: str | None = None
-    ean: str | None = None
-    purchase_steps: int | None = None
-    max_purchase: int | None = None
-    min_purchase: int | None = None
-    purchase_unit: float | None = None
-    reference_unit: float | None = None
-    shipping_free: bool | None = None
-    purchase_prices: list[dict[str, Any]] | None = None
-    mark_as_topseller: bool | None = None
-    weight: float | None = None
-    width: float | None = None
-    height: float | None = None
-    length: float | None = None
-    release_date: AwareDatetime | None = None
-    rating_average: float | None = Field(default=None, exclude=True)
-    category_tree: list[IdField] | None = Field(default=None, exclude=True)
-    property_ids: list[IdField] | None = Field(default=None, exclude=True)
-    option_ids: list[IdField] | None = Field(default=None, exclude=True)
-    stream_ids: list[IdField] | None = Field(default=None, exclude=True)
-    tag_ids: list[IdField] | None = Field(default=None, exclude=True)
-    category_ids: list[IdField] | None = Field(default=None, exclude=True)
-    child_count: int | None = Field(default=None, exclude=True)
-    custom_field_set_selection_active: bool | None = None
-    sales: int | None = Field(default=None, exclude=True)
-    states: list[str] | None = Field(default=None, exclude=True)
-    meta_description: str | None = None
-    name: str | None = None
-    keywords: str | None = None
-    description: str | None = None
-    meta_title: str | None = None
-    pack_unit: str | None = None
-    pack_unit_plural: str | None = None
-    custom_fields: dict[str, Any] | None = None
-    slot_config: dict[str, Any] | list | None = None
-    custom_search_keywords: list[str] | None = None
-    available_stock: int | None = Field(default=None, exclude=True)
-    stock: int | None = None
-    translated: dict[str, Any] | None = None
-
-    @field_validator('name')
+from shopware_api_client.endpoints.relations import ForeignRelation, ManyRelation
+from shopware_api_client.models.product import ProductBase
+
+
+class ProductValidators:
+    @field_validator("name")
     def ensure_name_or_parent(cls, value: str | None, info: FieldValidationInfo, **kwargs: Any) -> str | None:
-        if value is None and info.data['parent_id'] is None:
-            raise ValueError('name may only be empty if parent_id is set')
+        if value is None and info.data["parent_id"] is None:
+            raise ValueError("name may only be empty if parent_id is set")
 
         return value
 
-    @field_validator('tax_id')
+    @field_validator("tax_id")
     def ensure_tax_id_or_parent(cls, value: IdField | None, info: FieldValidationInfo, **kwargs: Any) -> IdField | None:
-        if value is None and info.data['parent_id'] is None:
-            raise ValueError('tax_id may only be empty if parent_id is set')
+        if value is None and info.data["parent_id"] is None:
+            raise ValueError("tax_id may only be empty if parent_id is set")
 
         return value
 
-    @field_validator('price')
-    def ensure_price_or_parent(cls, value: list[dict[str, Any]] | None, info: FieldValidationInfo, **kwargs: Any) -> list[dict[str, Any]] | None:
-        if value is None and info.data['parent_id'] is None:
-            raise ValueError('price may only be empty if parent_id is set')
+    @field_validator("price")
+    def ensure_price_or_parent(
+        cls, value: list[dict[str, Any]] | None, info: FieldValidationInfo, **kwargs: Any
+    ) -> list[dict[str, Any]] | None:
+        if value is None and info.data["parent_id"] is None:
+            raise ValueError("price may only be empty if parent_id is set")
 
         return value
 
-class ProductRelations:
+
+class Product(ProductBase, AdminModel["ProductEndpoint"], ProductValidators):
     downloads: ManyRelation["ProductDownload"]
     parent: ForeignRelation["Product"]
     children: ManyRelation["Product"]
@@ -122,7 +59,7 @@ class ProductRelations:
     order_line_items: ManyRelation["OrderLineItem"]
     wishlists: ManyRelation["CustomerWishlistProduct"]
     options: ManyRelation["PropertyGroupOption"]
-    properties: ManyRelation["PropertyGroupOption"]
+    properties: ManyRelation["PropertyGroup"]
     categories: ManyRelation["Category"]
     streams: ManyRelation["ProductStream"]
     categories_ro: ManyRelation["Category"]
@@ -134,11 +71,7 @@ class ProductRelations:
     """
 
 
-class Product(ProductBase["ProductEndpoint"], ProductRelations):
-    pass
-
-
-class ProductEndpoint(EndpointBase[Product]):
+class ProductEndpoint(AdminEndpoint[Product]):
     name = "product"
     path = "/product"
     model_class = Product
@@ -163,6 +96,7 @@ from .product_search_keyword import ProductSearchKeyword  # noqa: E402
 from .product_stream import ProductStream  # noqa: E402
 from .product_visibility import ProductVisibility  # noqa: E402
 from .property_group_option import PropertyGroupOption  # noqa: E402
+from .property_group import PropertyGroup  # noqa: E402
 from .seo_url import SeoUrl  # noqa: E402
 from .tag import Tag  # noqa: E402
 from .tax import Tax  # noqa: E402

shopware_api_client/endpoints/admin/core/product_configurator_setting.py

@@ -1,36 +1,15 @@
-from typing import Any
+from shopware_api_client.base import AdminModel, AdminEndpoint
+from shopware_api_client.endpoints.relations import ForeignRelation
+from shopware_api_client.models.product_configurator_setting import ProductConfiguratorSettingBase
 
-from ....base import ApiModelBase, EndpointBase, EndpointClass
-from ...base_fields import IdField
-from ...relations import ForeignRelation
 
-
-class ProductConfiguratorSettingBase(ApiModelBase[EndpointClass]):
-    _identifier: str = "product_configurator_setting"
-
-    version_id: IdField | None = None
-    product_id: IdField
-    product_version_id: IdField | None = None
-    media_id: IdField | None = None
-    option_id: IdField
-    price: dict[str, Any] | None = None
-    position: int | None = None
-    custom_fields: dict[str, Any] | None = None
-
-
-class ProductConfiguratorSettingRelations:
+class ProductConfiguratorSetting(ProductConfiguratorSettingBase, AdminModel["ProductConfiguratorSettingEndpoint"]):
     product: ForeignRelation["Product"]
     media: ForeignRelation["Media"]
     option: ForeignRelation["PropertyGroupOption"]
 
 
-class ProductConfiguratorSetting(
-    ProductConfiguratorSettingBase["ProductConfiguratorSettingEndpoint"], ProductConfiguratorSettingRelations
-):
-    pass
-
-
-class ProductConfiguratorSettingEndpoint(EndpointBase[ProductConfiguratorSetting]):
+class ProductConfiguratorSettingEndpoint(AdminEndpoint[ProductConfiguratorSetting]):
     name = "product_configurator_setting"
     path = "/product-configurator-setting"
     model_class = ProductConfiguratorSetting

shopware_api_client/endpoints/admin/core/product_cross_selling.py

@@ -1,37 +1,15 @@
-from typing import Any
+from shopware_api_client.base import AdminModel, AdminEndpoint
+from shopware_api_client.endpoints.relations import ForeignRelation, ManyRelation
+from shopware_api_client.models.product_cross_selling import ProductCrossSellingBase
 
-from ....base import ApiModelBase, EndpointBase, EndpointClass
-from ...base_fields import IdField
-from ...relations import ForeignRelation, ManyRelation
 
-
-class ProductCrossSellingBase(ApiModelBase[EndpointClass]):
-    _identifier: str = "product_cross_selling"
-
-    name: str
-    position: int
-    sort_by: str | None = None
-    sort_direction: str | None = None
-    type: str
-    active: bool | None = None
-    limit: int | None = None
-    product_id: IdField
-    product_version_id: IdField | None = None
-    product_stream_id: IdField | None = None
-    translated: dict[str, Any] | None = None
-
-
-class ProductCrossSellingRelations:
+class ProductCrossSelling(ProductCrossSellingBase, AdminModel["ProductCrossSellingEndpoint"]):
     product: ForeignRelation["Product"]
     product_stream: ForeignRelation["ProductStream"]
     assigned_products: ManyRelation["ProductCrossSellingAssignedProducts"]
 
 
-class ProductCrossSelling(ProductCrossSellingBase["ProductCrossSellingEndpoint"], ProductCrossSellingRelations):
-    pass
-
-
-class ProductCrossSellingEndpoint(EndpointBase[ProductCrossSelling]):
+class ProductCrossSellingEndpoint(AdminEndpoint[ProductCrossSelling]):
     name = "product_cross_selling"
     path = "/product-cross-selling"
     model_class = ProductCrossSelling

shopware_api_client/endpoints/admin/core/product_cross_selling_assigned_products.py

@@ -1,30 +1,16 @@
-from ....base import ApiModelBase, EndpointBase, EndpointClass
-from ...base_fields import IdField
-from ...relations import ForeignRelation
-
-
-class ProductCrossSellingAssignedProductsBase(ApiModelBase[EndpointClass]):
-    _identifier: str = "product_cross_selling_assigned_products"
-
-    cross_selling_id: IdField
-    product_id: IdField
-    product_version_id: IdField | None = None
-    position: int | None = None
-
-
-class ProductCrossSellingAssignedProductsRelations:
-    product: ForeignRelation["Product"]
-    cross_selling: ForeignRelation["ProductCrossSelling"]
+from shopware_api_client.base import AdminModel, AdminEndpoint
+from shopware_api_client.endpoints.relations import ForeignRelation
+from shopware_api_client.models.product_cross_selling_assigned_products import ProductCrossSellingAssignedProductsBase
 
 
 class ProductCrossSellingAssignedProducts(
-    ProductCrossSellingAssignedProductsBase["ProductCrossSellingAssignedProductsEndpoint"],
-    ProductCrossSellingAssignedProductsRelations,
+    ProductCrossSellingAssignedProductsBase, AdminModel["ProductCrossSellingAssignedProductsEndpoint"]
 ):
-    pass
+    product: ForeignRelation["Product"]
+    cross_selling: ForeignRelation["ProductCrossSelling"]
 
 
-class ProductCrossSellingAssignedProductsEndpoint(EndpointBase[ProductCrossSellingAssignedProducts]):
+class ProductCrossSellingAssignedProductsEndpoint(AdminEndpoint[ProductCrossSellingAssignedProducts]):
     name = "product_cross_selling_assigned_products"
     path = "/product-cross-selling-assigned-products"
     model_class = ProductCrossSellingAssignedProducts

shopware_api_client/endpoints/admin/core/product_download.py

@@ -1,31 +1,14 @@
-from typing import Any
+from shopware_api_client.base import AdminModel, AdminEndpoint
+from shopware_api_client.endpoints.relations import ForeignRelation
+from shopware_api_client.models.product_download import ProductDownloadBase
 
-from ....base import ApiModelBase, EndpointBase, EndpointClass
-from ...base_fields import IdField
-from ...relations import ForeignRelation
 
-
-class ProductDownloadBase(ApiModelBase[EndpointClass]):
-    _identifier: str = "product_download"
-
-    version_id: IdField | None = None
-    product_id: IdField
-    product_version_id: IdField | None = None
-    media_id: IdField
-    position: int | None = None
-    custom_fields: dict[str, Any] | None = None
-
-
-class ProductDownloadRelations:
+class ProductDownload(ProductDownloadBase, AdminModel["ProductDownloadEndpoint"]):
     product: ForeignRelation["Product"]
     media: ForeignRelation["Media"]
 
 
-class ProductDownload(ProductDownloadBase["ProductDownloadEndpoint"], ProductDownloadRelations):
-    pass
-
-
-class ProductDownloadEndpoint(EndpointBase[ProductDownload]):
+class ProductDownloadEndpoint(AdminEndpoint[ProductDownload]):
     name = "product_download"
     path = "/product-download"
     model_class = ProductDownload

shopware_api_client/endpoints/admin/core/product_export.py

@@ -1,34 +1,9 @@
-from pydantic import AwareDatetime
+from shopware_api_client.base import AdminModel, AdminEndpoint
+from shopware_api_client.endpoints.relations import ForeignRelation
+from shopware_api_client.models.product_export import ProductExportBase
 
-from ....base import ApiModelBase, EndpointBase, EndpointClass
-from ...base_fields import IdField
-from ...relations import ForeignRelation
 
-
-class ProductExportBase(ApiModelBase[EndpointClass]):
-    _identifier: str = "product_export"
-
-    product_stream_id: IdField
-    storefront_sales_channel_id: IdField
-    sales_channel_id: IdField
-    sales_channel_domain_id: IdField
-    currency_id: IdField
-    file_name: str
-    access_key: str
-    encoding: str
-    file_format: str
-    include_variants: bool | None = None
-    generate_by_cronjob: bool
-    generated_at: AwareDatetime | None = None
-    interval: int
-    header_template: str | None = None
-    body_template: str | None = None
-    footer_template: str | None = None
-    paused_schedule: bool | None = None
-    is_running: bool | None = None
-
-
-class ProductExportRelations:
+class ProductExport(ProductExportBase, AdminModel["ProductExportEndpoint"]):
     product_stream: ForeignRelation["ProductStream"]
     storefront_sales_channel: ForeignRelation["SalesChannel"]
     sales_channel: ForeignRelation["SalesChannel"]
@@ -36,11 +11,7 @@ class ProductExportRelations:
     currency: ForeignRelation["Currency"]
 
 
-class ProductExport(ProductExportBase["ProductExportEndpoint"], ProductExportRelations):
-    pass
-
-
-class ProductExportEndpoint(EndpointBase[ProductExport]):
+class ProductExportEndpoint(AdminEndpoint[ProductExport]):
     name = "product_export"
     path = "/product-export"
     model_class = ProductExport

shopware_api_client/endpoints/admin/core/product_feature_set.py

@@ -1,27 +1,13 @@
-from typing import Any
+from shopware_api_client.base import AdminModel, AdminEndpoint
+from shopware_api_client.endpoints.relations import ManyRelation
+from shopware_api_client.models.product_feature_set import ProductFeatureSetBase
 
-from ....base import ApiModelBase, EndpointBase, EndpointClass
-from ...relations import ManyRelation
 
-
-class ProductFeatureSetBase(ApiModelBase[EndpointClass]):
-    _identifier: str = "product_feature_set"
-
-    name: str
-    description: str | None = None
-    features: dict[str, Any] | None = None
-    translated: dict[str, Any] | None = None
-
-
-class ProductFeatureSetRelations:
+class ProductFeatureSet(ProductFeatureSetBase, AdminModel["ProductFeatureSetEndpoint"]):
     products: ManyRelation["Product"]
 
 
-class ProductFeatureSet(ProductFeatureSetBase["ProductFeatureSetEndpoint"], ProductFeatureSetRelations):
-    pass
-
-
-class ProductFeatureSetEndpoint(EndpointBase[ProductFeatureSet]):
+class ProductFeatureSetEndpoint(AdminEndpoint[ProductFeatureSet]):
     name = "product_feature_set"
     path = "/product-feature-set"
     model_class = ProductFeatureSet

shopware_api_client/endpoints/admin/core/product_manufacturer.py

@@ -1,32 +1,14 @@
-from typing import Any
+from shopware_api_client.base import AdminModel, AdminEndpoint
+from shopware_api_client.endpoints.relations import ForeignRelation, ManyRelation
+from shopware_api_client.models.product_manufacturer import ProductManufacturerBase
 
-from ....base import ApiModelBase, EndpointBase, EndpointClass
-from ...base_fields import IdField
-from ...relations import ForeignRelation, ManyRelation
 
-
-class ProductManufacturerBase(ApiModelBase[EndpointClass]):
-    _identifier: str = "product_manufacturer"
-
-    version_id: IdField | None = None
-    media_id: IdField | None = None
-    link: str | None = None
-    name: str
-    description: str | None = None
-    custom_fields: dict[str, Any] | None = None
-    translated: dict[str, Any] | None = None
-
-
-class ProductManufacturerRelations:
+class ProductManufacturer(ProductManufacturerBase, AdminModel["ProductManufacturerEndpoint"]):
     media: ForeignRelation["Media"]
     products: ManyRelation["Product"]
 
 
-class ProductManufacturer(ProductManufacturerBase["ProductManufacturerEndpoint"], ProductManufacturerRelations):
-    pass
-
-
-class ProductManufacturerEndpoint(EndpointBase[ProductManufacturer]):
+class ProductManufacturerEndpoint(AdminEndpoint[ProductManufacturer]):
     name = "product_manufacturer"
     path = "/product-manufacturer"
     model_class = ProductManufacturer

shopware_api_client/endpoints/admin/core/product_media.py

@@ -1,32 +1,15 @@
-from typing import Any
+from shopware_api_client.base import AdminModel, AdminEndpoint
+from shopware_api_client.endpoints.relations import ForeignRelation, ManyRelation
+from shopware_api_client.models.product_media import ProductMediaBase
 
-from ....base import ApiModelBase, EndpointBase, EndpointClass
-from ...base_fields import IdField
-from ...relations import ForeignRelation, ManyRelation
 
-
-class ProductMediaBase(ApiModelBase[EndpointClass]):
-    _identifier: str = "product_media"
-
-    version_id: IdField | None = None
-    product_id: IdField
-    product_version_id: IdField | None = None
-    media_id: IdField
-    position: int | None = None
-    custom_fields: dict[str, Any] | None = None
-
-
-class ProductMediaRelations:
+class ProductMedia(ProductMediaBase, AdminModel["ProductMediaEndpoint"]):
     product: ForeignRelation["Product"]
     media: ForeignRelation["Media"]
     cover_products: ManyRelation["Product"]
 
 
-class ProductMedia(ProductMediaBase["ProductMediaEndpoint"], ProductMediaRelations):
-    pass
-
-
-class ProductMediaEndpoint(EndpointBase[ProductMedia]):
+class ProductMediaEndpoint(AdminEndpoint[ProductMedia]):
     name = "product_media"
     path = "/product-media"
     model_class = ProductMedia

shopware_api_client/endpoints/admin/core/product_price.py

@@ -1,33 +1,14 @@
-from typing import Any
+from shopware_api_client.base import AdminModel, AdminEndpoint
+from shopware_api_client.endpoints.relations import ForeignRelation
+from shopware_api_client.models.product_price import ProductPriceBase
 
-from ....base import ApiModelBase, EndpointBase, EndpointClass
-from ...base_fields import IdField
-from ...relations import ForeignRelation
 
-
-class ProductPriceBase(ApiModelBase[EndpointClass]):
-    _identifier: str = "product_price"
-
-    version_id: IdField | None = None
-    product_id: IdField
-    product_version_id: IdField | None = None
-    rule_id: IdField
-    price: dict[str, Any]
-    quantity_start: int
-    quantity_end: int | None = None
-    custom_fields: dict[str, Any] | None = None
-
-
-class ProductPriceRelations:
+class ProductPrice(ProductPriceBase, AdminModel["ProductPriceEndpoint"]):
     product: ForeignRelation["Product"]
     rule: ForeignRelation["Rule"]
 
 
-class ProductPrice(ProductPriceBase["ProductPriceEndpoint"], ProductPriceRelations):
-    pass
-
-
-class ProductPriceEndpoint(EndpointBase[ProductPrice]):
+class ProductPriceEndpoint(AdminEndpoint[ProductPrice]):
     name = "product_price"
     path = "/product-price"
     model_class = ProductPrice

shopware_api_client/endpoints/admin/core/product_review.py

@@ -1,40 +1,16 @@
-from typing import Any
+from shopware_api_client.base import AdminModel, AdminEndpoint
+from shopware_api_client.endpoints.relations import ForeignRelation
+from shopware_api_client.models.product_review import ProductReviewBase
 
-from ....base import ApiModelBase, EndpointBase, EndpointClass
-from ...base_fields import IdField
-from ...relations import ForeignRelation
 
-
-class ProductReviewBase(ApiModelBase[EndpointClass]):
-    _identifier: str = "product_review"
-
-    product_id: IdField
-    product_version_id: IdField | None = None
-    customer_id: IdField | None = None
-    sales_channel_id: IdField
-    language_id: IdField
-    external_user: str | None = None
-    external_email: str | None = None
-    title: str
-    content: str
-    points: float | None = None
-    status: bool | None = None
-    comment: str | None = None
-    custom_fields: dict[str, Any] | None = None
-
-
-class ProductReviewRelations:
+class ProductReview(ProductReviewBase, AdminModel["ProductReviewEndpoint"]):
     product: ForeignRelation["Product"]
     customer: ForeignRelation["Customer"]
     sales_channel: ForeignRelation["SalesChannel"]
     language: ForeignRelation["Language"]
 
 
-class ProductReview(ProductReviewBase["ProductReviewEndpoint"], ProductReviewRelations):
-    pass
-
-
-class ProductReviewEndpoint(EndpointBase[ProductReview]):
+class ProductReviewEndpoint(AdminEndpoint[ProductReview]):
     name = "product_review"
     path = "/product-review"
     model_class = ProductReview

shopware_api_client/endpoints/admin/core/product_search_keyword.py

@@ -1,29 +1,14 @@
-from ....base import ApiModelBase, EndpointBase, EndpointClass
-from ...base_fields import IdField
-from ...relations import ForeignRelation
+from shopware_api_client.base import AdminModel, AdminEndpoint
+from shopware_api_client.endpoints.relations import ForeignRelation
+from shopware_api_client.models.product_search_keyword import ProductSearchKeywordBase
 
 
-class ProductSearchKeywordBase(ApiModelBase[EndpointClass]):
-    _identifier: str = "product_search_keyword"
-
-    version_id: IdField | None = None
-    language_id: IdField
-    product_id: IdField
-    product_version_id: IdField | None = None
-    keyword: str
-    ranking: float
-
-
-class ProductSearchKeywordRelations:
+class ProductSearchKeyword(ProductSearchKeywordBase, AdminModel["ProductSearchKeywordEndpoint"]):
     product: ForeignRelation["Product"]
     language: ForeignRelation["Language"]
 
 
-class ProductSearchKeyword(ProductSearchKeywordBase["ProductSearchKeywordEndpoint"], ProductSearchKeywordRelations):
-    pass
-
-
-class ProductSearchKeywordEndpoint(EndpointBase[ProductSearchKeyword]):
+class ProductSearchKeywordEndpoint(AdminEndpoint[ProductSearchKeyword]):
     name = "product_search_keyword"
     path = "/product-search-keyword"
     model_class = ProductSearchKeyword