visier-platform-sdk 22222222.99201.1914__py3-none-any.whl → 22222222.99201.1914b6__py3-none-any.whl

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.99201.1914
+    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.99201.1914
+    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
+
+

visier_platform_sdk/models/query_time_interval_dto.py

@@ -0,0 +1,134 @@
+# 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.1914
+    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, StrictInt, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from visier_platform_sdk.models.time_shift_dto import TimeShiftDTO
+from typing import Optional, Set
+from typing_extensions import Self
+
+class QueryTimeIntervalDTO(BaseModel):
+    """
+    A QueryTimeInterval defines the time interval to query, including the \"from\" time, period type,  period count, time direction, and shift to apply
+    """ # noqa: E501
+    from_instant: Optional[StrictStr] = Field(default=None, description="The instant from which to extend in the specified `direction`, in milliseconds since 1970-01-01T00:00:00Z.  Events that occur on this date are excluded. Subject-based data that ends on this date is included.  Note: Epochs are expressed as 64-bit integers and represented as stringified longs in JSON due to  JSON's inherent limitation in representing large numbers.", alias="fromInstant")
+    from_date_time: Optional[StrictStr] = Field(default=None, description="The instant from which to extend in the specified `direction`, as an ISO-8601 formatted date time string.  Valid formats: yyyy-MM-dd, yyyy-MM-dd'T'HH:mm:ss, yyyy-MM-dd'T'HH:mm:ss.SSS.  Events that occur on this date are excluded. Subject-based data that ends on this date is included.", alias="fromDateTime")
+    dynamic_date_from: Optional[StrictStr] = Field(default=None, description="Dynamically select the date from which to extend in the specified `direction`. Valid values are `SOURCE` or `COMPLETE_PERIOD`. Both options determine the date using the request's `source` field. Whether the source is a metric, formula, or metrics, each source has earliest and latest data available dates to use. The `direction` determines whether the earliest or latest date is used.   * If `dynamicDateFrom` is `SOURCE`, the query returns data from a date determined by the `source` query definition element. If `dynamicDateFrom` is `COMPLETE_PERIOD`, the query returns data starting from the latest or earliest date with a complete period of data. `COMPLETE_PERIOD` returns periods defined by `intervalPeriodType`. If the period type is MONTH, it returns full months of data. If the period type is YEAR, it returns full years of data. When `dynamicDateFrom` is specified:  * If `source` is `metric`, then `dynamicDateFrom` considers the date range of available data for the metric.  * If `source` is `formula`, then `dynamicDateFrom` considers the date range of available data for the metric in the formula.  * If `source` is `analyticObject`, then `dynamicDateFrom` considers the date range of available data for the analytic object.  Then, if `direction` is `BACKWARD`, query backward from the data **end** date and if `direction` is `FORWARD`, query forward from the data **start** date.  This allows you to keep getting the latest or earliest data without changing your query every time there's new or updated data.    Example: If a tenant has Headcount metric data available from 2023-01-01 to 2024-01-01 (End date exclusive), specifying `dynamicDateFrom`: `SOURCE` with `direction`: `BACKWARD`  means the query will retrieve data backward from 2024-01-01. The effect is the same as if specifying a `fromDateTime` of 2024-01-01'T'00:00:00.000.    Example: If a tenant has Employee subject data available from 2023-01-01 to 2024-01-01 (End date exclusive), specifying `dynamicDateFrom`: `SOURCE` with `direction`: `FORWARD`   means the query will retrieve data forward from 2023-01-01. The effect is the same as if specifying a `fromDateTime` of 2023-01-01'T'00:00:00.000.   Example: If a tenant has Employee subject data available from 2023-01-10 to 2023-04-01 (End date exclusive), specifying `dynamicDateFrom`: `COMPLETE_PERIOD` with `direction`: `FORWARD`   means the query will retrieve data forward from 2023-02-01. The effect is the same as if specifying a `fromDateTime` of 2023-02-01'T'00:00:00.000.   Example: If a tenant has Employee subject data available from 2023-01-01 to 2023-03-15 (End date exclusive), specifying `dynamicDateFrom`: `COMPLETE_PERIOD` with `direction`: `BACKWARD`   means the query will retrieve data backward from 2023-03-01. The effect is the same as if specifying a `fromDateTime` of 2023-03-01'T'00:00:00.000.   Example: Retrieve a list of EmployeeIDs for the formula extending 1 month backward from the dynamic source date       {           \"source\": {               \"formula\": \"on Employee validUntil instant filterBy(isActiveEmployee) aggregate count(Employee.EmployeeID)\"           },            \"columns\": [                {                   \"columnDefinition\": {                       \"property\": {                           \"name\": \"Employee.EmployeeID\",                           \"qualifyingPath\": \"Employee\"                       }                   }                },                {                   \"columnDefinition\": {                       \"effectiveDateProperty\": {}                   }                }           ],           \"timeInterval\": {               \"dynamicDateFrom\": \"SOURCE\",               \"intervalPeriodType\": \"MONTH\",               \"intervalPeriodCount\": 1,               \"direction\": \"BACKWARD\"           }       }", alias="dynamicDateFrom")
+    interval_period_type: Optional[StrictStr] = Field(default=None, description="The time period type for each interval. Default is MONTH.", alias="intervalPeriodType")
+    interval_period_count: Optional[StrictInt] = Field(default=None, description="The number of time periods per interval.", alias="intervalPeriodCount")
+    direction: Optional[StrictStr] = Field(default=None, description="The direction to extend. Default is BACKWARD. BACKWARD is useful when the time instant is the current date or with `dynamicDateFrom` because the query continuously retrieves the newest data from current date backwards.")
+    shift: Optional[TimeShiftDTO] = Field(default=None, description="The amount of time to shift the time interval by, such as backward by one year. Default is none.")
+    __properties: ClassVar[List[str]] = ["fromInstant", "fromDateTime", "dynamicDateFrom", "intervalPeriodType", "intervalPeriodCount", "direction", "shift"]
+
+    @field_validator('dynamic_date_from')
+    def dynamic_date_from_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['SOURCE', 'COMPLETE_PERIOD']):
+            raise ValueError("must be one of enum values ('SOURCE', 'COMPLETE_PERIOD')")
+        return value
+
+    @field_validator('interval_period_type')
+    def interval_period_type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['MONTH', 'DAY', 'WEEK', 'QUARTER', 'YEAR']):
+            raise ValueError("must be one of enum values ('MONTH', 'DAY', 'WEEK', 'QUARTER', 'YEAR')")
+        return value
+
+    @field_validator('direction')
+    def direction_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['BACKWARD', 'FORWARD']):
+            raise ValueError("must be one of enum values ('BACKWARD', 'FORWARD')")
+        return value
+
+    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 QueryTimeIntervalDTO 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 shift
+        if self.shift:
+            _dict['shift'] = self.shift.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of QueryTimeIntervalDTO from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "fromInstant": obj.get("fromInstant"),
+            "fromDateTime": obj.get("fromDateTime"),
+            "dynamicDateFrom": obj.get("dynamicDateFrom"),
+            "intervalPeriodType": obj.get("intervalPeriodType"),
+            "intervalPeriodCount": obj.get("intervalPeriodCount"),
+            "direction": obj.get("direction"),
+            "shift": TimeShiftDTO.from_dict(obj["shift"]) if obj.get("shift") is not None else None
+        })
+        return _obj
+
+

visier_platform_sdk/models/query_time_intervals_dto.py

@@ -0,0 +1,150 @@
+# 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.1914
+    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, StrictInt, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from visier_platform_sdk.models.time_shift_dto import TimeShiftDTO
+from typing import Optional, Set
+from typing_extensions import Self
+
+class QueryTimeIntervalsDTO(BaseModel):
+    """
+    A QueryTimeIntervals defines a series of time intervals to query, including the \"from\" time, period type, period count,  number of intervals, time direction, and shift to apply to each time interval.
+    """ # noqa: E501
+    from_instant: Optional[StrictStr] = Field(default=None, description="The instant from which to extend, in milliseconds since 1970-01-01T00:00:00Z.  Events that occur on this date are excluded. Subject-based data that ends on this date is included.  Note: Epochs are expressed as 64-bit integers and represented as stringified longs in JSON due to JSON's  inherent limitation in representing large numbers.", alias="fromInstant")
+    from_date_time: Optional[StrictStr] = Field(default=None, description="The instant from which to extend, as an ISO-8601 formatted date time string. This value is exclusive.  Valid formats: yyyy-MM-dd, yyyy-MM-dd'T'HH:mm:ss, yyyy-MM-dd'T'HH:mm:ss.SSS.  Events that occur on this date are excluded. Subject-based data that ends on this date is included.", alias="fromDateTime")
+    dynamic_date_from: Optional[StrictStr] = Field(default=None, description="Dynamically select the date from which to extend. Valid values are `SOURCE` or `COMPLETE_PERIOD`. Both options use the `source` query definition element to determine the date.   If `dynamicDateFrom` is `SOURCE`, the query returns data from a date determined by the `source` query definition element. If `dynamicDateFrom` is `COMPLETE_PERIOD`, the query returns data starting from the latest or earliest date with a complete period of data. When `dynamicDateFrom` is specified:  * If `source` is `metric`, then `dynamicDateFrom` considers the date range of available data for the metric.  * If `source` is `formula`, then `dynamicDateFrom` considers the date range of available data for the metric in the formula.  * If `source` is `metrics`, then `dynamicDateFrom` considers the date range of available data for the metric in the formula.  Then, if `direction` is `BACKWARD`, query backward from the data **end** date and if `direction` is `FORWARD`, query forward from the data **start** date.   This allows you to keep getting the latest or earliest data without changing your query every time there's new or updated data.   Note: For multi-metric queries, if `direction` is `BACKWARD`, query backward from the earliest data end date of all metrics and if `direction` is `FORWARD`, query forward from the latest data start date of all metrics.   This ensures that all metrics have data in the specified time range.   Example: If a tenant has Headcount metric data available from 2023-01-01 to 2024-01-01 (End date exclusive), specifying `dynamicDateFrom`: `SOURCE` with `direction`: `BACKWARD`   means the query will retrieve data backward from 2024-01-01. The effect is the same as if specifying a `fromDateTime` of 2024-01-01'T'00:00:00.000.    Example: If a tenant has Employee subject data available from 2023-01-10 to 2023-04-01 (End date exclusive), specifying `dynamicDateFrom`: `COMPLETE_PERIOD` with `direction`: `FORWARD`   means the query will retrieve data forward from 2023-02-01. The effect is the same as if specifying a `fromDateTime` of 2023-02-01'T'00:00:00.000.    Example: If a tenant has Employee subject data available from 2023-01-01 to 2023-03-15 (End date exclusive), specifying `dynamicDateFrom`: `COMPLETE_PERIOD` with `direction`: `BACKWARD`   means the query will retrieve data backward from 2023-03-01. The effect is the same as if specifying a `fromDateTime` of 2023-03-01'T'00:00:00.000.    Example: If a tenant has Headcount data available from 2023-01-01 to 2024-09-01 and Exit Count data available from 2023-01-01 to 2024-01-01, specifying `dynamicDateFrom`: `SOURCE` with `direction`: `BACKWARD` means the query will retrieve data backward from 2024-01-01.   Exit Count has an earlier data end date than Headcount, so `dynamicDateFrom` retrieves data backward from Exit Count's data end date to ensure both metrics have data in the specified time range.   Example: Retrieve Headcount (employeeCount) extending 1 month backward from Headcount's dynamic source date       {           \"query\": {               \"source\": {                   \"metric\": \"employeeCount\"               },               \"timeIntervals\": {                   \"dynamicDateFrom\": \"SOURCE\",                   \"intervalPeriodType\": \"MONTH\",                   \"intervalCount\": 1,                   \"direction\": \"BACKWARD\"               }           }       }", alias="dynamicDateFrom")
+    interval_period_type: Optional[StrictStr] = Field(default=None, description="The time period type for each interval. Default is MONTH.", alias="intervalPeriodType")
+    interval_period_count: Optional[StrictInt] = Field(default=None, description="The number of time periods per interval. Default is 1.", alias="intervalPeriodCount")
+    interval_count: Optional[StrictInt] = Field(default=None, description="The number of intervals. Default is 1.", alias="intervalCount")
+    direction: Optional[StrictStr] = Field(default=None, description="The direction to extend. Defaults is BACKWARD.")
+    shift: Optional[TimeShiftDTO] = Field(default=None, description="The amount of time to shift the time interval by, such as backward by one year.")
+    trailing_period_type: Optional[StrictStr] = Field(default=None, description="The time period type for each trailing period. If `trailingPeriodCount` is defined and `trailingPeriodType` is undefined, the default trailing period type is `MONTH`.  If both `trailingPeriodType` and `trailingPeriodCount` are undefined, `intervalPeriodCount` is used as the trailing period count.  Note: This parameter is only applicable to metrics that can calculate trailing time. If defined on a metric that doesn't have trailing time, the platform ignores the parameter.", alias="trailingPeriodType")
+    trailing_period_count: Optional[StrictInt] = Field(default=None, description="The number of time periods per trailing period. If `trailingPeriodType` is defined and `trailingPeriodCount` is undefined, the default trailing period count is 1.  Note: This parameter is only applicable to metrics that can calculate trailing time. If defined on a metric that doesn't have trailing time, the platform ignores the parameter.", alias="trailingPeriodCount")
+    __properties: ClassVar[List[str]] = ["fromInstant", "fromDateTime", "dynamicDateFrom", "intervalPeriodType", "intervalPeriodCount", "intervalCount", "direction", "shift", "trailingPeriodType", "trailingPeriodCount"]
+
+    @field_validator('dynamic_date_from')
+    def dynamic_date_from_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['SOURCE', 'COMPLETE_PERIOD']):
+            raise ValueError("must be one of enum values ('SOURCE', 'COMPLETE_PERIOD')")
+        return value
+
+    @field_validator('interval_period_type')
+    def interval_period_type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['MONTH', 'DAY', 'WEEK', 'QUARTER', 'YEAR']):
+            raise ValueError("must be one of enum values ('MONTH', 'DAY', 'WEEK', 'QUARTER', 'YEAR')")
+        return value
+
+    @field_validator('direction')
+    def direction_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['BACKWARD', 'FORWARD']):
+            raise ValueError("must be one of enum values ('BACKWARD', 'FORWARD')")
+        return value
+
+    @field_validator('trailing_period_type')
+    def trailing_period_type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['MONTH', 'DAY', 'WEEK', 'QUARTER', 'YEAR']):
+            raise ValueError("must be one of enum values ('MONTH', 'DAY', 'WEEK', 'QUARTER', 'YEAR')")
+        return value
+
+    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 QueryTimeIntervalsDTO 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 shift
+        if self.shift:
+            _dict['shift'] = self.shift.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of QueryTimeIntervalsDTO from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "fromInstant": obj.get("fromInstant"),
+            "fromDateTime": obj.get("fromDateTime"),
+            "dynamicDateFrom": obj.get("dynamicDateFrom"),
+            "intervalPeriodType": obj.get("intervalPeriodType"),
+            "intervalPeriodCount": obj.get("intervalPeriodCount"),
+            "intervalCount": obj.get("intervalCount"),
+            "direction": obj.get("direction"),
+            "shift": TimeShiftDTO.from_dict(obj["shift"]) if obj.get("shift") is not None else None,
+            "trailingPeriodType": obj.get("trailingPeriodType"),
+            "trailingPeriodCount": obj.get("trailingPeriodCount")
+        })
+        return _obj
+
+

visier_platform_sdk/models/question_categories_api_response_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.1914
+    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.question_category_api_response_dto import QuestionCategoryAPIResponseDTO
+from typing import Optional, Set
+from typing_extensions import Self
+
+class QuestionCategoriesAPIResponseDTO(BaseModel):
+    """
+    QuestionCategoriesAPIResponseDTO
+    """ # noqa: E501
+    categories: Optional[List[QuestionCategoryAPIResponseDTO]] = Field(default=None, description="A list of available categories for Vee sample questions.")
+    __properties: ClassVar[List[str]] = ["categories"]
+
+    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 QuestionCategoriesAPIResponseDTO 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 categories (list)
+        _items = []
+        if self.categories:
+            for _item_categories in self.categories:
+                if _item_categories:
+                    _items.append(_item_categories.to_dict())
+            _dict['categories'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of QuestionCategoriesAPIResponseDTO from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "categories": [QuestionCategoryAPIResponseDTO.from_dict(_item) for _item in obj["categories"]] if obj.get("categories") is not None else None
+        })
+        return _obj
+
+