visier-platform-sdk 22222222.99201.1892b3__py3-none-any.whl

visier_platform_sdk/models/dataservices_query_aggregation_query_dto.py

@@ -0,0 +1,128 @@
+# 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.99201.1892
+    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.dataservices_query_aggregation_query_source_dto import DataservicesQueryAggregationQuerySourceDTO
+from visier_platform_sdk.models.dataservices_query_query_axis_dto import DataservicesQueryQueryAxisDTO
+from visier_platform_sdk.models.dataservices_query_query_filter_dto import DataservicesQueryQueryFilterDTO
+from visier_platform_sdk.models.dataservices_query_query_parameter_value_dto import DataservicesQueryQueryParameterValueDTO
+from visier_platform_sdk.models.dataservices_query_query_time_intervals_dto import DataservicesQueryQueryTimeIntervalsDTO
+from typing import Optional, Set
+from typing_extensions import Self
+
+class DataservicesQueryAggregationQueryDTO(BaseModel):
+    """
+    An AggregationQuery defines the data to query in an aggregation query and returns a `cell set` calculated from  the selected data points.
+    """ # noqa: E501
+    source: Optional[DataservicesQueryAggregationQuerySourceDTO] = Field(default=None, description="The source data, such as a metric or formula, to query.")
+    filters: Optional[List[DataservicesQueryQueryFilterDTO]] = Field(default=None, description="The objects by which to filter the query, such as dimensions or concepts.  A filter defines the population to retrieve data from. Omit `filters` if no filtering is required.")
+    axes: Optional[List[DataservicesQueryQueryAxisDTO]] = Field(default=None, description="The objects by which to group the query. An axis defines the groups that the data belongs to.  Omit `axes` if no grouping is required.")
+    time_intervals: Optional[DataservicesQueryQueryTimeIntervalsDTO] = Field(default=None, description="The time intervals to query.", alias="timeIntervals")
+    parameter_values: Optional[List[DataservicesQueryQueryParameterValueDTO]] = Field(default=None, description="The values associated with parameters, if defined.", alias="parameterValues")
+    __properties: ClassVar[List[str]] = ["source", "filters", "axes", "timeIntervals", "parameterValues"]
+
+    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 DataservicesQueryAggregationQueryDTO 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 source
+        if self.source:
+            _dict['source'] = self.source.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in filters (list)
+        _items = []
+        if self.filters:
+            for _item_filters in self.filters:
+                if _item_filters:
+                    _items.append(_item_filters.to_dict())
+            _dict['filters'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in axes (list)
+        _items = []
+        if self.axes:
+            for _item_axes in self.axes:
+                if _item_axes:
+                    _items.append(_item_axes.to_dict())
+            _dict['axes'] = _items
+        # override the default output from pydantic by calling `to_dict()` of time_intervals
+        if self.time_intervals:
+            _dict['timeIntervals'] = self.time_intervals.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in parameter_values (list)
+        _items = []
+        if self.parameter_values:
+            for _item_parameter_values in self.parameter_values:
+                if _item_parameter_values:
+                    _items.append(_item_parameter_values.to_dict())
+            _dict['parameterValues'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of DataservicesQueryAggregationQueryDTO from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "source": DataservicesQueryAggregationQuerySourceDTO.from_dict(obj["source"]) if obj.get("source") is not None else None,
+            "filters": [DataservicesQueryQueryFilterDTO.from_dict(_item) for _item in obj["filters"]] if obj.get("filters") is not None else None,
+            "axes": [DataservicesQueryQueryAxisDTO.from_dict(_item) for _item in obj["axes"]] if obj.get("axes") is not None else None,
+            "timeIntervals": DataservicesQueryQueryTimeIntervalsDTO.from_dict(obj["timeIntervals"]) if obj.get("timeIntervals") is not None else None,
+            "parameterValues": [DataservicesQueryQueryParameterValueDTO.from_dict(_item) for _item in obj["parameterValues"]] if obj.get("parameterValues") is not None else None
+        })
+        return _obj
+
+

visier_platform_sdk/models/dataservices_query_aggregation_query_execution_dto.py

@@ -0,0 +1,98 @@
+# 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.99201.1892
+    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.dataservices_query_aggregation_query_dto import DataservicesQueryAggregationQueryDTO
+from visier_platform_sdk.models.dataservices_query_query_execution_options_dto import DataservicesQueryQueryExecutionOptionsDTO
+from typing import Optional, Set
+from typing_extensions import Self
+
+class DataservicesQueryAggregationQueryExecutionDTO(BaseModel):
+    """
+    An AggregationQueryExecution provides instructions to perform your aggregation query.
+    """ # noqa: E501
+    query: Optional[DataservicesQueryAggregationQueryDTO] = Field(default=None, description="The data to perform an aggregation on, such as a metric or formula. The query must include a time interval,  and may optionally include filters and axes.")
+    options: Optional[DataservicesQueryQueryExecutionOptionsDTO] = Field(default=None, description="Additional instructions for your query, such as a calendar type or conversion information.")
+    __properties: ClassVar[List[str]] = ["query", "options"]
+
+    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 DataservicesQueryAggregationQueryExecutionDTO 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 query
+        if self.query:
+            _dict['query'] = self.query.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of options
+        if self.options:
+            _dict['options'] = self.options.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of DataservicesQueryAggregationQueryExecutionDTO from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "query": DataservicesQueryAggregationQueryDTO.from_dict(obj["query"]) if obj.get("query") is not None else None,
+            "options": DataservicesQueryQueryExecutionOptionsDTO.from_dict(obj["options"]) if obj.get("options") is not None else None
+        })
+        return _obj
+
+

visier_platform_sdk/models/dataservices_query_aggregation_query_source_dto.py

@@ -0,0 +1,96 @@
+# 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.99201.1892
+    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.dataservices_query_aggregation_query_source_metrics_dto import DataservicesQueryAggregationQuerySourceMetricsDTO
+from typing import Optional, Set
+from typing_extensions import Self
+
+class DataservicesQueryAggregationQuerySourceDTO(BaseModel):
+    """
+    An AggregationQuerySource defines the source data to query in an aggregation query.
+    """ # noqa: E501
+    formula: Optional[StrictStr] = Field(default=None, description="An ad-hoc metric formula. The response returns the results of the aggregate.  See the formula dictionary in Visier to find functions and objects you can use in a formula.")
+    metric: Optional[StrictStr] = Field(default=None, description="The ID of an existing metric in your Visier solution. See `Metrics` to get the ID.")
+    metrics: Optional[DataservicesQueryAggregationQuerySourceMetricsDTO] = Field(default=None, description="The IDs of metrics to aggregate. All metrics in the query must reference the same analytic object.  For example, you cannot query Headcount and Applicant Count because one uses the Employee subject and  the other uses the Applicant subject. You can query Headcount and Employee Count for Women because both  reference the Employee subject. Only available when the Accept header is text/csv. For more information,  see `Aggregate`.")
+    __properties: ClassVar[List[str]] = ["formula", "metric", "metrics"]
+
+    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 DataservicesQueryAggregationQuerySourceDTO 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 metrics
+        if self.metrics:
+            _dict['metrics'] = self.metrics.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of DataservicesQueryAggregationQuerySourceDTO 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"),
+            "metric": obj.get("metric"),
+            "metrics": DataservicesQueryAggregationQuerySourceMetricsDTO.from_dict(obj["metrics"]) if obj.get("metrics") is not None else None
+        })
+        return _obj
+
+

visier_platform_sdk/models/dataservices_query_aggregation_query_source_metric_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.99201.1892
+    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 typing import Optional, Set
+from typing_extensions import Self
+
+class DataservicesQueryAggregationQuerySourceMetricDTO(BaseModel):
+    """
+    The column definition for a single metric within a `metrics` query.
+    """ # noqa: E501
+    column_name: Optional[StrictStr] = Field(default=None, description="The column name in the CSV file. Default is to use id as the column name.", alias="columnName")
+    id: Optional[StrictStr] = Field(default=None, description="The unique ID of the metric. Note: See `Metrics` to get the ID.  If columnName is omitted, id is the column name in the CSV file.")
+    formula: Optional[StrictStr] = Field(default=None, description="An ad-hoc metric formula. The response returns the results of the aggregate.  See the formula dictionary in Visier to find functions and objects you can use in a formula.")
+    qualifying_path: Optional[StrictStr] = Field(default=None, description="The base qualifying path to prefix the axes and filters' qualifying paths with.  You must specify the qualifying path on a metric if the convergent analytic object of the metric doesn't match the  starting object in the qualifying paths of the axes and filters.   For example, consider a multi-metric query that contains metrics that count the number of applicants and requisitions,  grouped by the country of the recruiter's direct manager. The following sample shows how to use qualifyingPath to specify  the object reference traversal path from each metric's convergent analytic object to the start of the path for the axes.  In this example, there is only one convergent analytic object.  ```  \"source\": {      \"metrics\": {         \"columns\": [             {                 \"id\": \"employeeCount\"             },             {                 \"id\": \"applicantCount\",                 \"qualifyingPath\": \"Applicant.Requisition.Recruiter\"             },             {                 \"id\": \"requisitionCount\",                 \"qualifyingPath\": \"Requisition.Recruiter\"             }         ]     }  },  \"axes\": [     {         \"dimensionLevelSelection\": {             \"dimension\": {                 \"name\": \"Location\",                 \"qualifyingPath\": \"Employee.Direct_Manager\"             },             \"levelIds\": [                 \"Location_1\"             ]         }     }  ]  ```  **Note:**  * `employeeCount` doesn't need a `qualifyingPath` because it's already convergent with the start of the axis path.  * The metrics' qualifying paths must provide the reference name that resolves to the first object of the axis' qualifying path as their last path segment. In this case, Recruiter is a named reference pointing to Employee. The final qualifying paths for the metrics are:      * `employeeCount`: Employee.Direct_Manager      * `applicantCount`: Applicant.Requisition.Recruiter.Direct_Manager      * `requisitionCount`: Requisition.Recruiter.Direct_Manager", alias="qualifyingPath")
+    __properties: ClassVar[List[str]] = ["columnName", "id", "formula", "qualifyingPath"]
+
+    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 DataservicesQueryAggregationQuerySourceMetricDTO 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 DataservicesQueryAggregationQuerySourceMetricDTO from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "columnName": obj.get("columnName"),
+            "id": obj.get("id"),
+            "formula": obj.get("formula"),
+            "qualifyingPath": obj.get("qualifyingPath")
+        })
+        return _obj
+
+

visier_platform_sdk/models/dataservices_query_aggregation_query_source_metrics_dto.py

@@ -0,0 +1,96 @@
+# 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.99201.1892
+    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.dataservices_query_aggregation_query_source_metric_dto import DataservicesQueryAggregationQuerySourceMetricDTO
+from typing import Optional, Set
+from typing_extensions import Self
+
+class DataservicesQueryAggregationQuerySourceMetricsDTO(BaseModel):
+    """
+    The IDs and column names of multiple metrics.   **Note:**  Only available when the `Accept` header is text/csv. For more information, see `Aggregate`
+    """ # noqa: E501
+    columns: Optional[List[DataservicesQueryAggregationQuerySourceMetricDTO]] = Field(default=None, description="An array of metric columns.")
+    __properties: ClassVar[List[str]] = ["columns"]
+
+    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 DataservicesQueryAggregationQuerySourceMetricsDTO 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 columns (list)
+        _items = []
+        if self.columns:
+            for _item_columns in self.columns:
+                if _item_columns:
+                    _items.append(_item_columns.to_dict())
+            _dict['columns'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of DataservicesQueryAggregationQuerySourceMetricsDTO from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "columns": [DataservicesQueryAggregationQuerySourceMetricDTO.from_dict(_item) for _item in obj["columns"]] if obj.get("columns") is not None else None
+        })
+        return _obj
+
+

visier_platform_sdk/models/dataservices_query_aggregation_type_parameter_value_dto.py

@@ -0,0 +1,90 @@
+# 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.99201.1892
+    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 typing import Optional, Set
+from typing_extensions import Self
+
+class DataservicesQueryAggregationTypeParameterValueDTO(BaseModel):
+    """
+    The value for an aggregation parameter.
+    """ # noqa: E501
+    parameter_id: Optional[StrictStr] = Field(default=None, description="The unique ID of the aggregation parameter.", alias="parameterId")
+    aggregation_option_id: Optional[StrictStr] = Field(default=None, description="The unique ID of the aggregation option.", alias="aggregationOptionId")
+    __properties: ClassVar[List[str]] = ["parameterId", "aggregationOptionId"]
+
+    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 DataservicesQueryAggregationTypeParameterValueDTO 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 DataservicesQueryAggregationTypeParameterValueDTO from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "parameterId": obj.get("parameterId"),
+            "aggregationOptionId": obj.get("aggregationOptionId")
+        })
+        return _obj
+
+