solvimon-python-sdk 0.0.4b0__py3-none-any.whl

solvimon_python_sdk/models/processing_settings.py

@@ -0,0 +1,89 @@
+# coding: utf-8
+
+"""
+    Solvimon API
+
+    Unified Solvimon API covering Configuration, Event, Identity, and Transaction domains.
+
+    The version of the OpenAPI document: 0.0.4-beta
+    Contact: contact@solvimon.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class ProcessingSettings(BaseModel):
+    """
+    ProcessingSettings
+    """ # noqa: E501
+    put_after_invoice_final_on_next_invoice: Optional[StrictBool] = Field(default=None, description="If enabled, moves usage to the next OPEN/DRAFT invoice when the matching invoice is already FINAL.")
+    __properties: ClassVar[List[str]] = ["put_after_invoice_final_on_next_invoice"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ProcessingSettings from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ProcessingSettings from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "put_after_invoice_final_on_next_invoice": obj.get("put_after_invoice_final_on_next_invoice")
+        })
+        return _obj
+
+

solvimon_python_sdk/models/processing_settings_update_request.py

@@ -0,0 +1,89 @@
+# coding: utf-8
+
+"""
+    Solvimon API
+
+    Unified Solvimon API covering Configuration, Event, Identity, and Transaction domains.
+
+    The version of the OpenAPI document: 0.0.4-beta
+    Contact: contact@solvimon.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class ProcessingSettingsUpdateRequest(BaseModel):
+    """
+    ProcessingSettingsUpdateRequest
+    """ # noqa: E501
+    put_after_invoice_final_on_next_invoice: Optional[StrictBool] = Field(default=None, description="If enabled, moves usage to the next OPEN/DRAFT invoice when the matching invoice is already FINAL.")
+    __properties: ClassVar[List[str]] = ["put_after_invoice_final_on_next_invoice"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ProcessingSettingsUpdateRequest from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ProcessingSettingsUpdateRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "put_after_invoice_final_on_next_invoice": obj.get("put_after_invoice_final_on_next_invoice")
+        })
+        return _obj
+
+

solvimon_python_sdk/models/product.py

@@ -0,0 +1,221 @@
+# coding: utf-8
+
+"""
+    Solvimon API
+
+    Unified Solvimon API covering Configuration, Event, Identity, and Transaction domains.
+
+    The version of the OpenAPI document: 0.0.4-beta
+    Contact: contact@solvimon.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from solvimon_python_sdk.models.agent_context import AgentContext
+from solvimon_python_sdk.models.custom_field_value import CustomFieldValue
+from solvimon_python_sdk.models.feature_resource_reference import FeatureResourceReference
+from solvimon_python_sdk.models.linked_integration import LinkedIntegration
+from solvimon_python_sdk.models.product_category import ProductCategory
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class Product(BaseModel):
+    """
+    Product
+    """ # noqa: E501
+    object_type: Optional[StrictStr] = None
+    id: Optional[StrictStr] = None
+    category_id: Optional[StrictStr] = Field(default=None, description="The resource ID of the product category, that belongs to the product.")
+    category: Optional[ProductCategory] = None
+    parent_product_id: Optional[StrictStr] = Field(default=None, description="The resource ID of the original product, to which the product will belong to.")
+    name: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=256)]] = None
+    reference: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=256)]] = None
+    description: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=256)]] = None
+    status: Optional[StrictStr] = Field(default=None, description="The status of the product.")
+    product_type: Optional[StrictStr] = None
+    tax_category: Optional[StrictStr] = Field(default=None, description="The default tax category applied to the product.")
+    features: Optional[List[FeatureResourceReference]] = Field(default=None, description="The features associated with the product.")
+    custom_fields: Optional[List[CustomFieldValue]] = None
+    display_order: Optional[Annotated[int, Field(strict=True)]] = Field(default=None, description="Determines the order in which products are displayed on overview pages and invoices. The lowest number gets the highest priority.")
+    linked_integrations: Optional[List[LinkedIntegration]] = None
+    billing_entity_id: Optional[StrictStr] = Field(default=None, description="The resource ID of the billing entity linked to this product.")
+    customer_id: Optional[StrictStr] = None
+    agent_context: Optional[AgentContext] = Field(default=None, description="Context for AI agents about this product. Intended for agents, not for customer-facing output.")
+    __properties: ClassVar[List[str]] = ["object_type", "id", "category_id", "category", "parent_product_id", "name", "reference", "description", "status", "product_type", "tax_category", "features", "custom_fields", "display_order", "linked_integrations", "billing_entity_id", "customer_id", "agent_context"]
+
+    @field_validator('name', mode="before")
+    def name_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if value is None:
+            return value
+
+        if isinstance(value, str) and not re.match(r"^.*$", value):
+            raise ValueError(r"must validate the regular expression /^.*$/")
+        return value
+
+    @field_validator('reference', mode="before")
+    def reference_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if value is None:
+            return value
+
+        if isinstance(value, str) and not re.match(r"^\S+$", value):
+            raise ValueError(r"must validate the regular expression /^\S+$/")
+        return value
+
+    @field_validator('description', mode="before")
+    def description_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if value is None:
+            return value
+
+        if isinstance(value, str) and not re.match(r"^.*$", value):
+            raise ValueError(r"must validate the regular expression /^.*$/")
+        return value
+
+    @field_validator('status')
+    def status_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['DRAFT', 'ACTIVE', 'ARCHIVED', 'DEPRECATED']):
+            raise ValueError("must be one of enum values ('DRAFT', 'ACTIVE', 'ARCHIVED', 'DEPRECATED')")
+        return value
+
+    @field_validator('product_type')
+    def product_type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['DEFAULT', 'ADDON']):
+            raise ValueError("must be one of enum values ('DEFAULT', 'ADDON')")
+        return value
+
+    @field_validator('tax_category')
+    def tax_category_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['STANDARD', 'NO_TAX', 'EXEMPT']):
+            raise ValueError("must be one of enum values ('STANDARD', 'NO_TAX', 'EXEMPT')")
+        return value
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of Product from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        * OpenAPI `readOnly` fields are excluded.
+        * OpenAPI `readOnly` fields are excluded.
+        * OpenAPI `readOnly` fields are excluded.
+        * OpenAPI `readOnly` fields are excluded.
+        """
+        excluded_fields: Set[str] = set([
+            "object_type",
+            "id",
+            "category",
+            "customer_id",
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of category
+        if self.category:
+            _dict['category'] = self.category.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in features (list)
+        _items = []
+        if self.features:
+            for _item_features in self.features:
+                _items.append(_item_features.to_dict() if _item_features is not None else None)
+            _dict['features'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in custom_fields (list)
+        _items = []
+        if self.custom_fields:
+            for _item_custom_fields in self.custom_fields:
+                _items.append(_item_custom_fields.to_dict() if _item_custom_fields is not None else None)
+            _dict['custom_fields'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in linked_integrations (list)
+        _items = []
+        if self.linked_integrations:
+            for _item_linked_integrations in self.linked_integrations:
+                _items.append(_item_linked_integrations.to_dict() if _item_linked_integrations is not None else None)
+            _dict['linked_integrations'] = _items
+        # override the default output from pydantic by calling `to_dict()` of agent_context
+        if self.agent_context:
+            _dict['agent_context'] = self.agent_context.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of Product from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "object_type": obj.get("object_type"),
+            "id": obj.get("id"),
+            "category_id": obj.get("category_id"),
+            "category": ProductCategory.from_dict(obj["category"]) if obj.get("category") is not None else None,
+            "parent_product_id": obj.get("parent_product_id"),
+            "name": obj.get("name"),
+            "reference": obj.get("reference"),
+            "description": obj.get("description"),
+            "status": obj.get("status"),
+            "product_type": obj.get("product_type"),
+            "tax_category": obj.get("tax_category"),
+            "features": [FeatureResourceReference.from_dict(_item) for _item in obj["features"]] if obj.get("features") is not None else None,
+            "custom_fields": [CustomFieldValue.from_dict(_item) for _item in obj["custom_fields"]] if obj.get("custom_fields") is not None else None,
+            "display_order": obj.get("display_order"),
+            "linked_integrations": [LinkedIntegration.from_dict(_item) for _item in obj["linked_integrations"]] if obj.get("linked_integrations") is not None else None,
+            "billing_entity_id": obj.get("billing_entity_id"),
+            "customer_id": obj.get("customer_id"),
+            "agent_context": AgentContext.from_dict(obj["agent_context"]) if obj.get("agent_context") is not None else None
+        })
+        return _obj
+
+

solvimon_python_sdk/models/product_category.py

@@ -0,0 +1,148 @@
+# coding: utf-8
+
+"""
+    Solvimon API
+
+    Unified Solvimon API covering Configuration, Event, Identity, and Transaction domains.
+
+    The version of the OpenAPI document: 0.0.4-beta
+    Contact: contact@solvimon.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class ProductCategory(BaseModel):
+    """
+    ProductCategory
+    """ # noqa: E501
+    object_type: Optional[StrictStr] = None
+    id: Optional[StrictStr] = None
+    name: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=256)]] = None
+    reference: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=256)]] = None
+    description: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=256)]] = None
+    tax_category: Optional[StrictStr] = Field(default=None, description="The default tax category applied to the products in the product category.")
+    display_order: Optional[Annotated[int, Field(strict=True)]] = None
+    customer_id: Optional[StrictStr] = Field(default=None, description="Resource ID of type CUSTOMER")
+    __properties: ClassVar[List[str]] = ["object_type", "id", "name", "reference", "description", "tax_category", "display_order", "customer_id"]
+
+    @field_validator('name', mode="before")
+    def name_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if value is None:
+            return value
+
+        if isinstance(value, str) and not re.match(r"^.*$", value):
+            raise ValueError(r"must validate the regular expression /^.*$/")
+        return value
+
+    @field_validator('reference', mode="before")
+    def reference_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if value is None:
+            return value
+
+        if isinstance(value, str) and not re.match(r"^\S+$", value):
+            raise ValueError(r"must validate the regular expression /^\S+$/")
+        return value
+
+    @field_validator('description', mode="before")
+    def description_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if value is None:
+            return value
+
+        if isinstance(value, str) and not re.match(r"^.*$", value):
+            raise ValueError(r"must validate the regular expression /^.*$/")
+        return value
+
+    @field_validator('tax_category')
+    def tax_category_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['STANDARD', 'NO_TAX', 'EXEMPT']):
+            raise ValueError("must be one of enum values ('STANDARD', 'NO_TAX', 'EXEMPT')")
+        return value
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ProductCategory from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        * OpenAPI `readOnly` fields are excluded.
+        * OpenAPI `readOnly` fields are excluded.
+        """
+        excluded_fields: Set[str] = set([
+            "object_type",
+            "id",
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ProductCategory from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "object_type": obj.get("object_type"),
+            "id": obj.get("id"),
+            "name": obj.get("name"),
+            "reference": obj.get("reference"),
+            "description": obj.get("description"),
+            "tax_category": obj.get("tax_category"),
+            "display_order": obj.get("display_order"),
+            "customer_id": obj.get("customer_id")
+        })
+        return _obj
+
+

solvimon_python_sdk/models/product_category_create_request.py

@@ -0,0 +1,142 @@
+# coding: utf-8
+
+"""
+    Solvimon API
+
+    Unified Solvimon API covering Configuration, Event, Identity, and Transaction domains.
+
+    The version of the OpenAPI document: 0.0.4-beta
+    Contact: contact@solvimon.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class ProductCategoryCreateRequest(BaseModel):
+    """
+    ProductCategoryCreateRequest
+    """ # noqa: E501
+    object_type: Optional[StrictStr] = None
+    id: Optional[StrictStr] = None
+    name: Annotated[str, Field(min_length=0, strict=True, max_length=256)]
+    reference: Annotated[str, Field(min_length=0, strict=True, max_length=256)]
+    description: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=256)]] = None
+    tax_category: Optional[StrictStr] = Field(default=None, description="The default tax category applied to the products in the product category.")
+    display_order: Optional[Annotated[int, Field(strict=True)]] = None
+    customer_id: Optional[StrictStr] = Field(default=None, description="Resource ID of type CUSTOMER")
+    __properties: ClassVar[List[str]] = ["object_type", "id", "name", "reference", "description", "tax_category", "display_order", "customer_id"]
+
+    @field_validator('name', mode="before")
+    def name_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if isinstance(value, str) and not re.match(r"^.*$", value):
+            raise ValueError(r"must validate the regular expression /^.*$/")
+        return value
+
+    @field_validator('reference', mode="before")
+    def reference_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if isinstance(value, str) and not re.match(r"^\S+$", value):
+            raise ValueError(r"must validate the regular expression /^\S+$/")
+        return value
+
+    @field_validator('description', mode="before")
+    def description_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if value is None:
+            return value
+
+        if isinstance(value, str) and not re.match(r"^.*$", value):
+            raise ValueError(r"must validate the regular expression /^.*$/")
+        return value
+
+    @field_validator('tax_category')
+    def tax_category_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['STANDARD', 'NO_TAX', 'EXEMPT']):
+            raise ValueError("must be one of enum values ('STANDARD', 'NO_TAX', 'EXEMPT')")
+        return value
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ProductCategoryCreateRequest from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        * OpenAPI `readOnly` fields are excluded.
+        * OpenAPI `readOnly` fields are excluded.
+        """
+        excluded_fields: Set[str] = set([
+            "object_type",
+            "id",
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ProductCategoryCreateRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "object_type": obj.get("object_type"),
+            "id": obj.get("id"),
+            "name": obj.get("name"),
+            "reference": obj.get("reference"),
+            "description": obj.get("description"),
+            "tax_category": obj.get("tax_category"),
+            "display_order": obj.get("display_order"),
+            "customer_id": obj.get("customer_id")
+        })
+        return _obj
+
+