visier-platform-sdk 22222222.99200.21494__py3-none-any.whl

visier_platform_sdk/models/query_filter_dto.py

@@ -0,0 +1,106 @@
+# coding: utf-8
+
+"""
+    API Reference
+
+    Detailed API reference documentation for Visier APIs. Includes all endpoints, headers, path parameters, query parameters, request body schema, response schema, JSON request samples, and JSON response samples.
+
+    The version of the OpenAPI document: 22222222.99200.21494
+    Contact: alpine@visier.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
+from typing import Any, ClassVar, Dict, List, Optional
+from visier_platform_sdk.models.cohort_filter_dto import CohortFilterDTO
+from visier_platform_sdk.models.member_filter_dto import MemberFilterDTO
+from visier_platform_sdk.models.selection_concept_reference_dto import SelectionConceptReferenceDTO
+from typing import Optional, Set
+from typing_extensions import Self
+
+class QueryFilterDTO(BaseModel):
+    """
+    A QueryFilter selects specific data points within a population.
+    """ # noqa: E501
+    formula: Optional[StrictStr] = Field(default=None, description="A filter expressed as a formula.")
+    selection_concept: Optional[SelectionConceptReferenceDTO] = Field(default=None, description="A filter that uses an existing selection concept in Visier.", alias="selectionConcept")
+    member_set: Optional[MemberFilterDTO] = Field(default=None, description="A filter that includes or excludes dimension members.", alias="memberSet")
+    cohort: Optional[CohortFilterDTO] = Field(default=None, description="A filter that identifies a population at a specific time.")
+    __properties: ClassVar[List[str]] = ["formula", "selectionConcept", "memberSet", "cohort"]
+
+    model_config = ConfigDict(
+        populate_by_name=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"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of QueryFilterDTO 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 selection_concept
+        if self.selection_concept:
+            _dict['selectionConcept'] = self.selection_concept.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of member_set
+        if self.member_set:
+            _dict['memberSet'] = self.member_set.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of cohort
+        if self.cohort:
+            _dict['cohort'] = self.cohort.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of QueryFilterDTO from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "formula": obj.get("formula"),
+            "selectionConcept": SelectionConceptReferenceDTO.from_dict(obj["selectionConcept"]) if obj.get("selectionConcept") is not None else None,
+            "memberSet": MemberFilterDTO.from_dict(obj["memberSet"]) if obj.get("memberSet") is not None else None,
+            "cohort": CohortFilterDTO.from_dict(obj["cohort"]) if obj.get("cohort") is not None else None
+        })
+        return _obj
+
+

visier_platform_sdk/models/query_member_map_property_dto.py

@@ -0,0 +1,94 @@
+# coding: utf-8
+
+"""
+    API Reference
+
+    Detailed API reference documentation for Visier APIs. Includes all endpoints, headers, path parameters, query parameters, request body schema, response schema, JSON request samples, and JSON response samples.
+
+    The version of the OpenAPI document: 22222222.99200.21494
+    Contact: alpine@visier.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
+from typing import Any, ClassVar, Dict, List, Optional
+from visier_platform_sdk.models.dimension_reference_dto import DimensionReferenceDTO
+from typing import Optional, Set
+from typing_extensions import Self
+
+class QueryMemberMapPropertyDTO(BaseModel):
+    """
+    A QueryMemberMapProperty defines an existing member map and its dimension to query.
+    """ # noqa: E501
+    member_map: Optional[DimensionReferenceDTO] = Field(default=None, description="A member map and its qualifying path to query.", alias="memberMap")
+    target_dimension_name: Optional[StrictStr] = Field(default=None, description="The name of the member map's dimension that you want to query. The member selection is based on this dimension.", alias="targetDimensionName")
+    __properties: ClassVar[List[str]] = ["memberMap", "targetDimensionName"]
+
+    model_config = ConfigDict(
+        populate_by_name=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"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of QueryMemberMapPropertyDTO 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 member_map
+        if self.member_map:
+            _dict['memberMap'] = self.member_map.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of QueryMemberMapPropertyDTO from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "memberMap": DimensionReferenceDTO.from_dict(obj["memberMap"]) if obj.get("memberMap") is not None else None,
+            "targetDimensionName": obj.get("targetDimensionName")
+        })
+        return _obj
+
+

visier_platform_sdk/models/query_member_map_selection_dto.py

@@ -0,0 +1,104 @@
+# coding: utf-8
+
+"""
+    API Reference
+
+    Detailed API reference documentation for Visier APIs. Includes all endpoints, headers, path parameters, query parameters, request body schema, response schema, JSON request samples, and JSON response samples.
+
+    The version of the OpenAPI document: 22222222.99200.21494
+    Contact: alpine@visier.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
+from typing import Any, ClassVar, Dict, List, Optional
+from visier_platform_sdk.models.dimension_member_reference_dto import DimensionMemberReferenceDTO
+from visier_platform_sdk.models.dimension_reference_dto import DimensionReferenceDTO
+from typing import Optional, Set
+from typing_extensions import Self
+
+class QueryMemberMapSelectionDTO(BaseModel):
+    """
+    A QueryMemberMapSelection groups data in a query by dimension members in a member map.  This allows grouping by a dimension that isn't typically valid on the analytic object being  queried by selecting a valid member map on the analytic object.  Note: This is unique to the data query API and cannot be reproduced in Visier's interface.
+    """ # noqa: E501
+    member_map: Optional[DimensionReferenceDTO] = Field(default=None, description="A member map and its qualifying path to query.", alias="memberMap")
+    target_dimension_name: Optional[StrictStr] = Field(default=None, description="The name of the member map's dimension that you want to query. The member selection is based on this dimension.", alias="targetDimensionName")
+    members: Optional[List[DimensionMemberReferenceDTO]] = Field(default=None, description="A collection of the selected dimension members from the `targetDimension`. This must contain at least one member.")
+    __properties: ClassVar[List[str]] = ["memberMap", "targetDimensionName", "members"]
+
+    model_config = ConfigDict(
+        populate_by_name=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"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of QueryMemberMapSelectionDTO 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 member_map
+        if self.member_map:
+            _dict['memberMap'] = self.member_map.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in members (list)
+        _items = []
+        if self.members:
+            for _item_members in self.members:
+                if _item_members:
+                    _items.append(_item_members.to_dict())
+            _dict['members'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of QueryMemberMapSelectionDTO from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "memberMap": DimensionReferenceDTO.from_dict(obj["memberMap"]) if obj.get("memberMap") is not None else None,
+            "targetDimensionName": obj.get("targetDimensionName"),
+            "members": [DimensionMemberReferenceDTO.from_dict(_item) for _item in obj["members"]] if obj.get("members") is not None else None
+        })
+        return _obj
+
+

visier_platform_sdk/models/query_numeric_ranges_dto.py

@@ -0,0 +1,100 @@
+# coding: utf-8
+
+"""
+    API Reference
+
+    Detailed API reference documentation for Visier APIs. Includes all endpoints, headers, path parameters, query parameters, request body schema, response schema, JSON request samples, and JSON response samples.
+
+    The version of the OpenAPI document: 22222222.99200.21494
+    Contact: alpine@visier.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, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from visier_platform_sdk.models.query_property_dto import QueryPropertyDTO
+from typing import Optional, Set
+from typing_extensions import Self
+
+class QueryNumericRangesDTO(BaseModel):
+    """
+    A QueryNumericRanges groups data into specified ranges based on a property value.
+    """ # noqa: E501
+    var_property: Optional[QueryPropertyDTO] = Field(default=None, description="The name and qualifying path of a numeric property. Non-numeric properties are not accepted.", alias="property")
+    ranges: Optional[StrictStr] = Field(default=None, description="The ranges to group data into, expressed as a space-separated string of range-bound values.")
+    include_negative: Optional[StrictBool] = Field(default=None, description="If `true`, negative ranges are included. Default is false.", alias="includeNegative")
+    include_independent_zero_range: Optional[StrictBool] = Field(default=None, description="If `true`, 0 is an independent range. Default is false.", alias="includeIndependentZeroRange")
+    include_all_member: Optional[StrictBool] = Field(default=None, description="If `true`, a member is included that represents all members on the axis. Default is false.", alias="includeAllMember")
+    __properties: ClassVar[List[str]] = ["property", "ranges", "includeNegative", "includeIndependentZeroRange", "includeAllMember"]
+
+    model_config = ConfigDict(
+        populate_by_name=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"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of QueryNumericRangesDTO 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 var_property
+        if self.var_property:
+            _dict['property'] = self.var_property.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of QueryNumericRangesDTO from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "property": QueryPropertyDTO.from_dict(obj["property"]) if obj.get("property") is not None else None,
+            "ranges": obj.get("ranges"),
+            "includeNegative": obj.get("includeNegative"),
+            "includeIndependentZeroRange": obj.get("includeIndependentZeroRange"),
+            "includeAllMember": obj.get("includeAllMember")
+        })
+        return _obj
+
+

visier_platform_sdk/models/query_parameter_value_dto.py

@@ -0,0 +1,110 @@
+# coding: utf-8
+
+"""
+    API Reference
+
+    Detailed API reference documentation for Visier APIs. Includes all endpoints, headers, path parameters, query parameters, request body schema, response schema, JSON request samples, and JSON response samples.
+
+    The version of the OpenAPI document: 22222222.99200.21494
+    Contact: alpine@visier.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
+from typing import Any, ClassVar, Dict, List, Optional
+from visier_platform_sdk.models.aggregation_type_parameter_value_dto import AggregationTypeParameterValueDTO
+from visier_platform_sdk.models.member_parameter_value_dto import MemberParameterValueDTO
+from visier_platform_sdk.models.numeric_parameter_value_dto import NumericParameterValueDTO
+from visier_platform_sdk.models.plan_parameter_value_dto import PlanParameterValueDTO
+from typing import Optional, Set
+from typing_extensions import Self
+
+class QueryParameterValueDTO(BaseModel):
+    """
+    An object that contains parameter values for either member or numeric parameters.
+    """ # noqa: E501
+    member_value: Optional[MemberParameterValueDTO] = Field(default=None, description="A value for a member parameter.", alias="memberValue")
+    numeric_value: Optional[NumericParameterValueDTO] = Field(default=None, description="A value for a numeric parameter.", alias="numericValue")
+    plan_value: Optional[PlanParameterValueDTO] = Field(default=None, description="A value for a plan parameter.", alias="planValue")
+    aggregation_type_value: Optional[AggregationTypeParameterValueDTO] = Field(default=None, description="A value for an aggregation parameter.", alias="aggregationTypeValue")
+    __properties: ClassVar[List[str]] = ["memberValue", "numericValue", "planValue", "aggregationTypeValue"]
+
+    model_config = ConfigDict(
+        populate_by_name=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"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of QueryParameterValueDTO 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 member_value
+        if self.member_value:
+            _dict['memberValue'] = self.member_value.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of numeric_value
+        if self.numeric_value:
+            _dict['numericValue'] = self.numeric_value.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of plan_value
+        if self.plan_value:
+            _dict['planValue'] = self.plan_value.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of aggregation_type_value
+        if self.aggregation_type_value:
+            _dict['aggregationTypeValue'] = self.aggregation_type_value.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of QueryParameterValueDTO from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "memberValue": MemberParameterValueDTO.from_dict(obj["memberValue"]) if obj.get("memberValue") is not None else None,
+            "numericValue": NumericParameterValueDTO.from_dict(obj["numericValue"]) if obj.get("numericValue") is not None else None,
+            "planValue": PlanParameterValueDTO.from_dict(obj["planValue"]) if obj.get("planValue") is not None else None,
+            "aggregationTypeValue": AggregationTypeParameterValueDTO.from_dict(obj["aggregationTypeValue"]) if obj.get("aggregationTypeValue") is not None else None
+        })
+        return _obj
+
+

visier_platform_sdk/models/query_property_dto.py

@@ -0,0 +1,120 @@
+# coding: utf-8
+
+"""
+    API Reference
+
+    Detailed API reference documentation for Visier APIs. Includes all endpoints, headers, path parameters, query parameters, request body schema, response schema, JSON request samples, and JSON response samples.
+
+    The version of the OpenAPI document: 22222222.99200.21494
+    Contact: alpine@visier.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
+from typing import Any, ClassVar, Dict, List, Optional
+from visier_platform_sdk.models.dimension_reference_dto import DimensionReferenceDTO
+from visier_platform_sdk.models.property_reference_dto import PropertyReferenceDTO
+from visier_platform_sdk.models.query_dimension_level_property_dto import QueryDimensionLevelPropertyDTO
+from visier_platform_sdk.models.query_member_map_property_dto import QueryMemberMapPropertyDTO
+from visier_platform_sdk.models.selection_concept_reference_dto import SelectionConceptReferenceDTO
+from typing import Optional, Set
+from typing_extensions import Self
+
+class QueryPropertyDTO(BaseModel):
+    """
+    A QueryProperty defines a property of a data point returned from a query.  This is not the same as a `property` in Visier's data mode.
+    """ # noqa: E501
+    formula: Optional[StrictStr] = Field(default=None, description="A formula-based property.")
+    var_property: Optional[PropertyReferenceDTO] = Field(default=None, description="A property reference.", alias="property")
+    selection_concept: Optional[SelectionConceptReferenceDTO] = Field(default=None, description="A selection concept-based property that returns true or false.", alias="selectionConcept")
+    dimension: Optional[DimensionReferenceDTO] = Field(default=None, description="A dimension-based property that returns the full name path of the dimension member that the data point is mapped to.")
+    member_map_property: Optional[QueryMemberMapPropertyDTO] = Field(default=None, description="A member map-based property that uses an existing member map in Visier.", alias="memberMapProperty")
+    effective_date_property: Optional[Dict[str, Any]] = Field(default=None, description="A property that yields the effective date for the record", alias="effectiveDateProperty")
+    dimension_level_selection: Optional[QueryDimensionLevelPropertyDTO] = Field(default=None, description="A dimension-based property that returns the member values of the dimension level.", alias="dimensionLevelSelection")
+    __properties: ClassVar[List[str]] = ["formula", "property", "selectionConcept", "dimension", "memberMapProperty", "effectiveDateProperty", "dimensionLevelSelection"]
+
+    model_config = ConfigDict(
+        populate_by_name=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"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of QueryPropertyDTO 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 var_property
+        if self.var_property:
+            _dict['property'] = self.var_property.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of selection_concept
+        if self.selection_concept:
+            _dict['selectionConcept'] = self.selection_concept.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of dimension
+        if self.dimension:
+            _dict['dimension'] = self.dimension.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of member_map_property
+        if self.member_map_property:
+            _dict['memberMapProperty'] = self.member_map_property.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of dimension_level_selection
+        if self.dimension_level_selection:
+            _dict['dimensionLevelSelection'] = self.dimension_level_selection.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of QueryPropertyDTO from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "formula": obj.get("formula"),
+            "property": PropertyReferenceDTO.from_dict(obj["property"]) if obj.get("property") is not None else None,
+            "selectionConcept": SelectionConceptReferenceDTO.from_dict(obj["selectionConcept"]) if obj.get("selectionConcept") is not None else None,
+            "dimension": DimensionReferenceDTO.from_dict(obj["dimension"]) if obj.get("dimension") is not None else None,
+            "memberMapProperty": QueryMemberMapPropertyDTO.from_dict(obj["memberMapProperty"]) if obj.get("memberMapProperty") is not None else None,
+            "effectiveDateProperty": obj.get("effectiveDateProperty"),
+            "dimensionLevelSelection": QueryDimensionLevelPropertyDTO.from_dict(obj["dimensionLevelSelection"]) if obj.get("dimensionLevelSelection") is not None else None
+        })
+        return _obj
+
+