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

solvimon_python_sdk/models/meter_data_create_request.py

@@ -0,0 +1,190 @@
+# 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 datetime import datetime
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from solvimon_python_sdk.models.cost_prediction_create_request import CostPredictionCreateRequest
+from solvimon_python_sdk.models.customer_create_request_event import CustomerCreateRequestEvent
+from solvimon_python_sdk.models.meter_data_meter_property_create_request import MeterDataMeterPropertyCreateRequest
+from solvimon_python_sdk.models.meter_data_meter_value_create_request import MeterDataMeterValueCreateRequest
+from solvimon_python_sdk.models.meter_data_processed_details_create_request import MeterDataProcessedDetailsCreateRequest
+from solvimon_python_sdk.models.pricing_plan_subscription_selector_create_request import PricingPlanSubscriptionSelectorCreateRequest
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class MeterDataCreateRequest(BaseModel):
+    """
+    MeterDataCreateRequest
+    """ # noqa: E501
+    object_type: Optional[StrictStr] = None
+    id: Optional[StrictStr] = None
+    reference: Annotated[str, Field(min_length=10, strict=True, max_length=256)]
+    type: Optional[StrictStr] = Field(default=None, description="The type of meter data.")
+    customer_id: Optional[StrictStr] = Field(default=None, description="The resource ID of the associated customer.")
+    customer_reference: Optional[StrictStr] = Field(default=None, description="A custom reference assigned to the customer.")
+    customer: Optional[CustomerCreateRequestEvent] = None
+    meter_id: Optional[StrictStr] = Field(default=None, description="The resource ID of the meter.")
+    meter_reference: Optional[StrictStr] = Field(default=None, description="A custom reference assigned to the meter.")
+    pricing_plan_subscription_id: Optional[StrictStr] = Field(default=None, description="The resource ID of the associated pricing plan subscription.")
+    pricing_plan_subscription_reference: Optional[StrictStr] = Field(default=None, description="A custom reference assigned to the pricing plan subscription.")
+    pricing_plan_subscription_selector: Optional[PricingPlanSubscriptionSelectorCreateRequest] = Field(default=None, description="A selector to dynamically determine the subscription to use.")
+    timestamp: Optional[datetime] = Field(default=None, description="The associated timestamp presented in the ISO 8601 standard of the charge event, if not provided it will be set to 'now'.")
+    created_at: Optional[StrictStr] = Field(default=None, description="The associated timestamp presented in the ISO 8601 standard of the creation of the event in Solvimon.")
+    meter_properties: Optional[List[MeterDataMeterPropertyCreateRequest]] = Field(default=None, description="The properties that provide information to give context to an event, used in the meter.")
+    meter_values: Optional[List[MeterDataMeterValueCreateRequest]] = Field(default=None, description="The values used as input to calculate billable units, used in the meter.")
+    cost_prediction: Optional[CostPredictionCreateRequest] = Field(default=None, description="The cost prediction.")
+    processed_details: Optional[MeterDataProcessedDetailsCreateRequest] = Field(default=None, description="Details of the result of processing the event.")
+    deleted: Optional[StrictBool] = Field(default=None, description="Is MeterData marked as deleted.")
+    __properties: ClassVar[List[str]] = ["object_type", "id", "reference", "type", "customer_id", "customer_reference", "customer", "meter_id", "meter_reference", "pricing_plan_subscription_id", "pricing_plan_subscription_reference", "pricing_plan_subscription_selector", "timestamp", "created_at", "meter_properties", "meter_values", "cost_prediction", "processed_details", "deleted"]
+
+    @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"^.*$", value):
+            raise ValueError(r"must validate the regular expression /^.*$/")
+        return value
+
+    @field_validator('type')
+    def type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['INGEST', 'CALCULATION']):
+            raise ValueError("must be one of enum values ('INGEST', 'CALCULATION')")
+        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 MeterDataCreateRequest 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.
+        * 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",
+            "type",
+            "customer",
+            "created_at",
+            "cost_prediction",
+            "processed_details",
+            "deleted",
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of customer
+        if self.customer:
+            _dict['customer'] = self.customer.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of pricing_plan_subscription_selector
+        if self.pricing_plan_subscription_selector:
+            _dict['pricing_plan_subscription_selector'] = self.pricing_plan_subscription_selector.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in meter_properties (list)
+        _items = []
+        if self.meter_properties:
+            for _item_meter_properties in self.meter_properties:
+                _items.append(_item_meter_properties.to_dict() if _item_meter_properties is not None else None)
+            _dict['meter_properties'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in meter_values (list)
+        _items = []
+        if self.meter_values:
+            for _item_meter_values in self.meter_values:
+                _items.append(_item_meter_values.to_dict() if _item_meter_values is not None else None)
+            _dict['meter_values'] = _items
+        # override the default output from pydantic by calling `to_dict()` of cost_prediction
+        if self.cost_prediction:
+            _dict['cost_prediction'] = self.cost_prediction.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of processed_details
+        if self.processed_details:
+            _dict['processed_details'] = self.processed_details.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of MeterDataCreateRequest 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"),
+            "reference": obj.get("reference"),
+            "type": obj.get("type"),
+            "customer_id": obj.get("customer_id"),
+            "customer_reference": obj.get("customer_reference"),
+            "customer": CustomerCreateRequestEvent.from_dict(obj["customer"]) if obj.get("customer") is not None else None,
+            "meter_id": obj.get("meter_id"),
+            "meter_reference": obj.get("meter_reference"),
+            "pricing_plan_subscription_id": obj.get("pricing_plan_subscription_id"),
+            "pricing_plan_subscription_reference": obj.get("pricing_plan_subscription_reference"),
+            "pricing_plan_subscription_selector": PricingPlanSubscriptionSelectorCreateRequest.from_dict(obj["pricing_plan_subscription_selector"]) if obj.get("pricing_plan_subscription_selector") is not None else None,
+            "timestamp": obj.get("timestamp"),
+            "created_at": obj.get("created_at"),
+            "meter_properties": [MeterDataMeterPropertyCreateRequest.from_dict(_item) for _item in obj["meter_properties"]] if obj.get("meter_properties") is not None else None,
+            "meter_values": [MeterDataMeterValueCreateRequest.from_dict(_item) for _item in obj["meter_values"]] if obj.get("meter_values") is not None else None,
+            "cost_prediction": CostPredictionCreateRequest.from_dict(obj["cost_prediction"]) if obj.get("cost_prediction") is not None else None,
+            "processed_details": MeterDataProcessedDetailsCreateRequest.from_dict(obj["processed_details"]) if obj.get("processed_details") is not None else None,
+            "deleted": obj.get("deleted")
+        })
+        return _obj
+
+

solvimon_python_sdk/models/meter_data_file_processing_settings.py

@@ -0,0 +1,104 @@
+# 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, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from solvimon_python_sdk.models.column_mapping import ColumnMapping
+from solvimon_python_sdk.models.meter_data_mapping_settings import MeterDataMappingSettings
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class MeterDataFileProcessingSettings(BaseModel):
+    """
+    MeterDataFileProcessingSettings
+    """ # noqa: E501
+    mapping_column: Optional[StrictStr] = None
+    mappings: Optional[List[MeterDataMappingSettings]] = None
+    customer_reference_mapping: Optional[ColumnMapping] = None
+    __properties: ClassVar[List[str]] = ["mapping_column", "mappings", "customer_reference_mapping"]
+
+    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 MeterDataFileProcessingSettings 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,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each item in mappings (list)
+        _items = []
+        if self.mappings:
+            for _item_mappings in self.mappings:
+                _items.append(_item_mappings.to_dict() if _item_mappings is not None else None)
+            _dict['mappings'] = _items
+        # override the default output from pydantic by calling `to_dict()` of customer_reference_mapping
+        if self.customer_reference_mapping:
+            _dict['customer_reference_mapping'] = self.customer_reference_mapping.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of MeterDataFileProcessingSettings from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "mapping_column": obj.get("mapping_column"),
+            "mappings": [MeterDataMappingSettings.from_dict(_item) for _item in obj["mappings"]] if obj.get("mappings") is not None else None,
+            "customer_reference_mapping": ColumnMapping.from_dict(obj["customer_reference_mapping"]) if obj.get("customer_reference_mapping") is not None else None
+        })
+        return _obj
+
+

solvimon_python_sdk/models/meter_data_file_processing_settings_create_request.py

@@ -0,0 +1,104 @@
+# 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, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from solvimon_python_sdk.models.column_mapping import ColumnMapping
+from solvimon_python_sdk.models.meter_data_mapping_settings import MeterDataMappingSettings
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class MeterDataFileProcessingSettingsCreateRequest(BaseModel):
+    """
+    MeterDataFileProcessingSettingsCreateRequest
+    """ # noqa: E501
+    mapping_column: Optional[StrictStr] = None
+    mappings: Optional[List[MeterDataMappingSettings]] = None
+    customer_reference_mapping: Optional[ColumnMapping] = None
+    __properties: ClassVar[List[str]] = ["mapping_column", "mappings", "customer_reference_mapping"]
+
+    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 MeterDataFileProcessingSettingsCreateRequest 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,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each item in mappings (list)
+        _items = []
+        if self.mappings:
+            for _item_mappings in self.mappings:
+                _items.append(_item_mappings.to_dict() if _item_mappings is not None else None)
+            _dict['mappings'] = _items
+        # override the default output from pydantic by calling `to_dict()` of customer_reference_mapping
+        if self.customer_reference_mapping:
+            _dict['customer_reference_mapping'] = self.customer_reference_mapping.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of MeterDataFileProcessingSettingsCreateRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "mapping_column": obj.get("mapping_column"),
+            "mappings": [MeterDataMappingSettings.from_dict(_item) for _item in obj["mappings"]] if obj.get("mappings") is not None else None,
+            "customer_reference_mapping": ColumnMapping.from_dict(obj["customer_reference_mapping"]) if obj.get("customer_reference_mapping") is not None else None
+        })
+        return _obj
+
+

solvimon_python_sdk/models/meter_data_file_processing_settings_update_request.py

@@ -0,0 +1,104 @@
+# 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, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from solvimon_python_sdk.models.column_mapping import ColumnMapping
+from solvimon_python_sdk.models.meter_data_mapping_settings import MeterDataMappingSettings
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class MeterDataFileProcessingSettingsUpdateRequest(BaseModel):
+    """
+    MeterDataFileProcessingSettingsUpdateRequest
+    """ # noqa: E501
+    mapping_column: Optional[StrictStr] = None
+    mappings: Optional[List[MeterDataMappingSettings]] = None
+    customer_reference_mapping: Optional[ColumnMapping] = None
+    __properties: ClassVar[List[str]] = ["mapping_column", "mappings", "customer_reference_mapping"]
+
+    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 MeterDataFileProcessingSettingsUpdateRequest 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,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each item in mappings (list)
+        _items = []
+        if self.mappings:
+            for _item_mappings in self.mappings:
+                _items.append(_item_mappings.to_dict() if _item_mappings is not None else None)
+            _dict['mappings'] = _items
+        # override the default output from pydantic by calling `to_dict()` of customer_reference_mapping
+        if self.customer_reference_mapping:
+            _dict['customer_reference_mapping'] = self.customer_reference_mapping.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of MeterDataFileProcessingSettingsUpdateRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "mapping_column": obj.get("mapping_column"),
+            "mappings": [MeterDataMappingSettings.from_dict(_item) for _item in obj["mappings"]] if obj.get("mappings") is not None else None,
+            "customer_reference_mapping": ColumnMapping.from_dict(obj["customer_reference_mapping"]) if obj.get("customer_reference_mapping") is not None else None
+        })
+        return _obj
+
+

solvimon_python_sdk/models/meter_data_mapping_settings.py

@@ -0,0 +1,119 @@
+# 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, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from solvimon_python_sdk.models.ingest_reference_mapping import IngestReferenceMapping
+from solvimon_python_sdk.models.meter_property_mapping import MeterPropertyMapping
+from solvimon_python_sdk.models.meter_value_mapping import MeterValueMapping
+from solvimon_python_sdk.models.reference_mapping_interface import ReferenceMappingInterface
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class MeterDataMappingSettings(BaseModel):
+    """
+    MeterDataMappingSettings
+    """ # noqa: E501
+    column_values: Optional[List[StrictStr]] = None
+    meter_reference_mapping: Optional[ReferenceMappingInterface] = None
+    ingest_reference_mapping: Optional[IngestReferenceMapping] = None
+    meter_property_mappings: Optional[List[MeterPropertyMapping]] = None
+    meter_value_mappings: Optional[List[MeterValueMapping]] = None
+    __properties: ClassVar[List[str]] = ["column_values", "meter_reference_mapping", "ingest_reference_mapping", "meter_property_mappings", "meter_value_mappings"]
+
+    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 MeterDataMappingSettings 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,
+        )
+        # override the default output from pydantic by calling `to_dict()` of meter_reference_mapping
+        if self.meter_reference_mapping:
+            _dict['meter_reference_mapping'] = self.meter_reference_mapping.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of ingest_reference_mapping
+        if self.ingest_reference_mapping:
+            _dict['ingest_reference_mapping'] = self.ingest_reference_mapping.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in meter_property_mappings (list)
+        _items = []
+        if self.meter_property_mappings:
+            for _item_meter_property_mappings in self.meter_property_mappings:
+                _items.append(_item_meter_property_mappings.to_dict() if _item_meter_property_mappings is not None else None)
+            _dict['meter_property_mappings'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in meter_value_mappings (list)
+        _items = []
+        if self.meter_value_mappings:
+            for _item_meter_value_mappings in self.meter_value_mappings:
+                _items.append(_item_meter_value_mappings.to_dict() if _item_meter_value_mappings is not None else None)
+            _dict['meter_value_mappings'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of MeterDataMappingSettings from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "column_values": obj.get("column_values"),
+            "meter_reference_mapping": ReferenceMappingInterface.from_dict(obj["meter_reference_mapping"]) if obj.get("meter_reference_mapping") is not None else None,
+            "ingest_reference_mapping": IngestReferenceMapping.from_dict(obj["ingest_reference_mapping"]) if obj.get("ingest_reference_mapping") is not None else None,
+            "meter_property_mappings": [MeterPropertyMapping.from_dict(_item) for _item in obj["meter_property_mappings"]] if obj.get("meter_property_mappings") is not None else None,
+            "meter_value_mappings": [MeterValueMapping.from_dict(_item) for _item in obj["meter_value_mappings"]] if obj.get("meter_value_mappings") is not None else None
+        })
+        return _obj
+
+