nominal-api 0.914.0__py3-none-any.whl → 0.916.0__py3-none-any.whl

nominal_api/__init__.py

@@ -81,5 +81,5 @@ __all__ = [
 
 __conjure_generator_version__ = "4.17.0"
 
-__version__ = "0.914.0"
+__version__ = "0.916.0"
 

nominal_api/_impl.py

@@ -14405,27 +14405,27 @@ class module_CreateModuleRequest(ConjureBeanType):
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'name': ConjureFieldDefinition('name', str),
+            'api_name': ConjureFieldDefinition('apiName', str),
             'title': ConjureFieldDefinition('title', str),
             'description': ConjureFieldDefinition('description', str),
             'definition': ConjureFieldDefinition('definition', module_ModuleVersionDefinition),
             'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_rids_WorkspaceRid])
         }
 
-    __slots__: List[str] = ['_name', '_title', '_description', '_definition', '_workspace']
+    __slots__: List[str] = ['_api_name', '_title', '_description', '_definition', '_workspace']
 
-    def __init__(self, definition: "module_ModuleVersionDefinition", description: str, name: str, title: str, workspace: Optional[str] = None) -> None:
-        self._name = name
+    def __init__(self, api_name: str, definition: "module_ModuleVersionDefinition", description: str, title: str, workspace: Optional[str] = None) -> None:
+        self._api_name = api_name
         self._title = title
         self._description = description
         self._definition = definition
         self._workspace = workspace
 
     @builtins.property
-    def name(self) -> str:
-        """The name of the module. This should be unique to the module in the current workspace.
+    def api_name(self) -> str:
+        """The API name for the module. This string will uniquely identify the module within the organization.
         """
-        return self._name
+        return self._api_name
 
     @builtins.property
     def title(self) -> str:
@@ -14456,18 +14456,18 @@ class module_DerivedSeriesMetadata(ConjureBeanType):
         return {
             'function_name': ConjureFieldDefinition('functionName', str),
             'function_description': ConjureFieldDefinition('functionDescription', str),
-            'module_name': ConjureFieldDefinition('moduleName', str),
+            'module_api_name': ConjureFieldDefinition('moduleApiName', str),
             'module_application_rid': ConjureFieldDefinition('moduleApplicationRid', modules_api_ModuleApplicationRid),
             'application_resolved_parameters': ConjureFieldDefinition('applicationResolvedParameters', List[module_ModuleVariable]),
             'data_type': ConjureFieldDefinition('dataType', module_ValueType)
         }
 
-    __slots__: List[str] = ['_function_name', '_function_description', '_module_name', '_module_application_rid', '_application_resolved_parameters', '_data_type']
+    __slots__: List[str] = ['_function_name', '_function_description', '_module_api_name', '_module_application_rid', '_application_resolved_parameters', '_data_type']
 
-    def __init__(self, application_resolved_parameters: List["module_ModuleVariable"], data_type: "module_ValueType", function_description: str, function_name: str, module_application_rid: str, module_name: str) -> None:
+    def __init__(self, application_resolved_parameters: List["module_ModuleVariable"], data_type: "module_ValueType", function_description: str, function_name: str, module_api_name: str, module_application_rid: str) -> None:
         self._function_name = function_name
         self._function_description = function_description
-        self._module_name = module_name
+        self._module_api_name = module_api_name
         self._module_application_rid = module_application_rid
         self._application_resolved_parameters = application_resolved_parameters
         self._data_type = data_type
@@ -14481,8 +14481,8 @@ class module_DerivedSeriesMetadata(ConjureBeanType):
         return self._function_description
 
     @builtins.property
-    def module_name(self) -> str:
-        return self._module_name
+    def module_api_name(self) -> str:
+        return self._module_api_name
 
     @builtins.property
     def module_application_rid(self) -> str:
@@ -14875,7 +14875,7 @@ class module_ModuleMetadata(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'rid': ConjureFieldDefinition('rid', modules_api_ModuleRid),
-            'name': ConjureFieldDefinition('name', str),
+            'api_name': ConjureFieldDefinition('apiName', str),
             'title': ConjureFieldDefinition('title', str),
             'description': ConjureFieldDefinition('description', str),
             'created_by': ConjureFieldDefinition('createdBy', scout_rids_api_UserRid),
@@ -14883,11 +14883,11 @@ class module_ModuleMetadata(ConjureBeanType):
             'archived_at': ConjureFieldDefinition('archivedAt', OptionalTypeWrapper[str])
         }
 
-    __slots__: List[str] = ['_rid', '_name', '_title', '_description', '_created_by', '_created_at', '_archived_at']
+    __slots__: List[str] = ['_rid', '_api_name', '_title', '_description', '_created_by', '_created_at', '_archived_at']
 
-    def __init__(self, created_at: str, created_by: str, description: str, name: str, rid: str, title: str, archived_at: Optional[str] = None) -> None:
+    def __init__(self, api_name: str, created_at: str, created_by: str, description: str, rid: str, title: str, archived_at: Optional[str] = None) -> None:
         self._rid = rid
-        self._name = name
+        self._api_name = api_name
         self._title = title
         self._description = description
         self._created_by = created_by
@@ -14899,11 +14899,11 @@ class module_ModuleMetadata(ConjureBeanType):
         return self._rid
 
     @builtins.property
-    def name(self) -> str:
-        """The API name for the module. This uniquely identifies the module within the org.
+    def api_name(self) -> str:
+        """This uniquely identifies the module within the org.
 Note that this cannot be changed after creation.
         """
-        return self._name
+        return self._api_name
 
     @builtins.property
     def title(self) -> str:
@@ -14968,15 +14968,15 @@ class module_ModuleRef(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'rid': ConjureFieldDefinition('rid', modules_api_ModuleRid),
-            'name': ConjureFieldDefinition('name', str),
+            'api_name': ConjureFieldDefinition('apiName', str),
             'version': ConjureFieldDefinition('version', module_ModuleVersion)
         }
 
-    __slots__: List[str] = ['_rid', '_name', '_version']
+    __slots__: List[str] = ['_rid', '_api_name', '_version']
 
-    def __init__(self, name: str, rid: str, version: str) -> None:
+    def __init__(self, api_name: str, rid: str, version: str) -> None:
         self._rid = rid
-        self._name = name
+        self._api_name = api_name
         self._version = version
 
     @builtins.property
@@ -14984,8 +14984,8 @@ class module_ModuleRef(ConjureBeanType):
         return self._rid
 
     @builtins.property
-    def name(self) -> str:
-        return self._name
+    def api_name(self) -> str:
+        return self._api_name
 
     @builtins.property
     def version(self) -> str:
@@ -14999,7 +14999,7 @@ module_ModuleRef.__module__ = "nominal_api.module"
 
 class module_ModuleService(Service):
     """Modules define collections of compute logic that can be shared and used across different contexts by applying them
-to assets. The Modules Service provides the api for managing these collections and using them.
+to assets. The Modules Service provides the API for managing these collections and using them.
     """
 
     def create_module(self, auth_header: str, request: "module_CreateModuleRequest") -> "module_Module":
@@ -15536,19 +15536,19 @@ class module_RequestModuleNameRef(ConjureBeanType):
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'name': ConjureFieldDefinition('name', str),
+            'api_name': ConjureFieldDefinition('apiName', str),
             'version_strategy': ConjureFieldDefinition('versionStrategy', module_VersionStrategy)
         }
 
-    __slots__: List[str] = ['_name', '_version_strategy']
+    __slots__: List[str] = ['_api_name', '_version_strategy']
 
-    def __init__(self, name: str, version_strategy: "module_VersionStrategy") -> None:
-        self._name = name
+    def __init__(self, api_name: str, version_strategy: "module_VersionStrategy") -> None:
+        self._api_name = api_name
         self._version_strategy = version_strategy
 
     @builtins.property
-    def name(self) -> str:
-        return self._name
+    def api_name(self) -> str:
+        return self._api_name
 
     @builtins.property
     def version_strategy(self) -> "module_VersionStrategy":
@@ -16544,25 +16544,25 @@ class module_internal_ModuleComputeDefinition(ConjureBeanType):
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'module_name': ConjureFieldDefinition('moduleName', str),
+            'module_api_name': ConjureFieldDefinition('moduleApiName', str),
             'module_rid': ConjureFieldDefinition('moduleRid', modules_api_ModuleRid),
             'version': ConjureFieldDefinition('version', module_ModuleVersion),
             'default_variables': ConjureFieldDefinition('defaultVariables', List[module_ModuleVariable]),
             'functions': ConjureFieldDefinition('functions', List[module_Function])
         }
 
-    __slots__: List[str] = ['_module_name', '_module_rid', '_version', '_default_variables', '_functions']
+    __slots__: List[str] = ['_module_api_name', '_module_rid', '_version', '_default_variables', '_functions']
 
-    def __init__(self, default_variables: List["module_ModuleVariable"], functions: List["module_Function"], module_name: str, module_rid: str, version: str) -> None:
-        self._module_name = module_name
+    def __init__(self, default_variables: List["module_ModuleVariable"], functions: List["module_Function"], module_api_name: str, module_rid: str, version: str) -> None:
+        self._module_api_name = module_api_name
         self._module_rid = module_rid
         self._version = version
         self._default_variables = default_variables
         self._functions = functions
 
     @builtins.property
-    def module_name(self) -> str:
-        return self._module_name
+    def module_api_name(self) -> str:
+        return self._module_api_name
 
     @builtins.property
     def module_rid(self) -> str:
@@ -43210,6 +43210,7 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
     _numeric: Optional["scout_compute_api_NumericPlot"] = None
     _bucketed_numeric: Optional["scout_compute_api_BucketedNumericPlot"] = None
     _numeric_point: Optional[Optional["scout_compute_api_NumericPoint"]] = None
+    _single_point: Optional[Optional["scout_compute_api_SinglePoint"]] = None
     _arrow_numeric: Optional["scout_compute_api_ArrowNumericPlot"] = None
     _arrow_bucketed_numeric: Optional["scout_compute_api_ArrowBucketedNumericPlot"] = None
     _enum: Optional["scout_compute_api_EnumPlot"] = None
@@ -43239,6 +43240,7 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
             'numeric': ConjureFieldDefinition('numeric', scout_compute_api_NumericPlot),
             'bucketed_numeric': ConjureFieldDefinition('bucketedNumeric', scout_compute_api_BucketedNumericPlot),
             'numeric_point': ConjureFieldDefinition('numericPoint', OptionalTypeWrapper[scout_compute_api_NumericPoint]),
+            'single_point': ConjureFieldDefinition('singlePoint', OptionalTypeWrapper[scout_compute_api_SinglePoint]),
             'arrow_numeric': ConjureFieldDefinition('arrowNumeric', scout_compute_api_ArrowNumericPlot),
             'arrow_bucketed_numeric': ConjureFieldDefinition('arrowBucketedNumeric', scout_compute_api_ArrowBucketedNumericPlot),
             'enum': ConjureFieldDefinition('enum', scout_compute_api_EnumPlot),
@@ -43268,6 +43270,7 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
             numeric: Optional["scout_compute_api_NumericPlot"] = None,
             bucketed_numeric: Optional["scout_compute_api_BucketedNumericPlot"] = None,
             numeric_point: Optional[Optional["scout_compute_api_NumericPoint"]] = None,
+            single_point: Optional[Optional["scout_compute_api_SinglePoint"]] = None,
             arrow_numeric: Optional["scout_compute_api_ArrowNumericPlot"] = None,
             arrow_bucketed_numeric: Optional["scout_compute_api_ArrowBucketedNumericPlot"] = None,
             enum: Optional["scout_compute_api_EnumPlot"] = None,
@@ -43290,7 +43293,7 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (range is not None) + (ranges_summary is not None) + (range_value is not None) + (numeric is not None) + (bucketed_numeric is not None) + (numeric_point is not None) + (arrow_numeric is not None) + (arrow_bucketed_numeric is not None) + (enum is not None) + (enum_point is not None) + (bucketed_enum is not None) + (arrow_enum is not None) + (arrow_bucketed_enum is not None) + (paged_log is not None) + (log_point is not None) + (cartesian is not None) + (bucketed_cartesian is not None) + (bucketed_cartesian3d is not None) + (bucketed_geo is not None) + (frequency_domain is not None) + (numeric_histogram is not None) + (enum_histogram is not None) + (curve_fit is not None) + (grouped is not None) + (array is not None) != 1:
+            if (range is not None) + (ranges_summary is not None) + (range_value is not None) + (numeric is not None) + (bucketed_numeric is not None) + (numeric_point is not None) + (single_point is not None) + (arrow_numeric is not None) + (arrow_bucketed_numeric is not None) + (enum is not None) + (enum_point is not None) + (bucketed_enum is not None) + (arrow_enum is not None) + (arrow_bucketed_enum is not None) + (paged_log is not None) + (log_point is not None) + (cartesian is not None) + (bucketed_cartesian is not None) + (bucketed_cartesian3d is not None) + (bucketed_geo is not None) + (frequency_domain is not None) + (numeric_histogram is not None) + (enum_histogram is not None) + (curve_fit is not None) + (grouped is not None) + (array is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if range is not None:
@@ -43311,6 +43314,9 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
             if numeric_point is not None:
                 self._numeric_point = numeric_point
                 self._type = 'numericPoint'
+            if single_point is not None:
+                self._single_point = single_point
+                self._type = 'singlePoint'
             if arrow_numeric is not None:
                 self._arrow_numeric = arrow_numeric
                 self._type = 'arrowNumeric'
@@ -43399,6 +43405,11 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._numeric_point = numeric_point
             self._type = 'numericPoint'
+        elif type_of_union == 'singlePoint':
+            if single_point is None:
+                raise ValueError('a union value must not be None')
+            self._single_point = single_point
+            self._type = 'singlePoint'
         elif type_of_union == 'arrowNumeric':
             if arrow_numeric is None:
                 raise ValueError('a union value must not be None')
@@ -43519,6 +43530,10 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
     def numeric_point(self) -> Optional[Optional["scout_compute_api_NumericPoint"]]:
         return self._numeric_point
 
+    @builtins.property
+    def single_point(self) -> Optional[Optional["scout_compute_api_SinglePoint"]]:
+        return self._single_point
+
     @builtins.property
     def arrow_numeric(self) -> Optional["scout_compute_api_ArrowNumericPlot"]:
         return self._arrow_numeric
@@ -43610,6 +43625,8 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
             return visitor._bucketed_numeric(self.bucketed_numeric)
         if self._type == 'numericPoint' and self.numeric_point is not None:
             return visitor._numeric_point(self.numeric_point)
+        if self._type == 'singlePoint' and self.single_point is not None:
+            return visitor._single_point(self.single_point)
         if self._type == 'arrowNumeric' and self.arrow_numeric is not None:
             return visitor._arrow_numeric(self.arrow_numeric)
         if self._type == 'arrowBucketedNumeric' and self.arrow_bucketed_numeric is not None:
@@ -43681,6 +43698,10 @@ class scout_compute_api_ComputeNodeResponseVisitor:
     def _numeric_point(self, numeric_point: Optional["scout_compute_api_NumericPoint"]) -> Any:
         pass
 
+    @abstractmethod
+    def _single_point(self, single_point: Optional["scout_compute_api_SinglePoint"]) -> Any:
+        pass
+
     @abstractmethod
     def _arrow_numeric(self, arrow_numeric: "scout_compute_api_ArrowNumericPlot") -> Any:
         pass
@@ -50736,6 +50757,46 @@ scout_compute_api_OutputRangeStartVisitor.__qualname__ = "OutputRangeStartVisito
 scout_compute_api_OutputRangeStartVisitor.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_PaddedRanges(ConjureBeanType):
+    """Expands ranges durations by adding temporal padding to the start, end, or both sides. Note that if the input
+ranges contain a RangeValue, it will be dropped.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'input': ConjureFieldDefinition('input', scout_compute_api_RangeSeries),
+            'padding': ConjureFieldDefinition('padding', scout_compute_api_DurationConstant),
+            'padding_configuration': ConjureFieldDefinition('paddingConfiguration', OptionalTypeWrapper[scout_compute_api_RangePaddingConfiguration])
+        }
+
+    __slots__: List[str] = ['_input', '_padding', '_padding_configuration']
+
+    def __init__(self, input: "scout_compute_api_RangeSeries", padding: "scout_compute_api_DurationConstant", padding_configuration: Optional["scout_compute_api_RangePaddingConfiguration"] = None) -> None:
+        self._input = input
+        self._padding = padding
+        self._padding_configuration = padding_configuration
+
+    @builtins.property
+    def input(self) -> "scout_compute_api_RangeSeries":
+        return self._input
+
+    @builtins.property
+    def padding(self) -> "scout_compute_api_DurationConstant":
+        return self._padding
+
+    @builtins.property
+    def padding_configuration(self) -> Optional["scout_compute_api_RangePaddingConfiguration"]:
+        """Configuration for how to apply padding to the ranges. Defaults to PAD_START_AND_END if not specified.
+        """
+        return self._padding_configuration
+
+
+scout_compute_api_PaddedRanges.__name__ = "PaddedRanges"
+scout_compute_api_PaddedRanges.__qualname__ = "PaddedRanges"
+scout_compute_api_PaddedRanges.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_PageInfo(ConjureBeanType):
     """Specification of a page for a series. Returns raw undecimated points beginning nearest to the given page
 token, advancing pageSize points in the time direction specified by the sign of the page size.
@@ -51883,6 +51944,26 @@ scout_compute_api_RangeMap.__qualname__ = "RangeMap"
 scout_compute_api_RangeMap.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_RangePaddingConfiguration(ConjureEnumType):
+
+    PAD_START = 'PAD_START'
+    '''PAD_START'''
+    PAD_END = 'PAD_END'
+    '''PAD_END'''
+    PAD_START_AND_END = 'PAD_START_AND_END'
+    '''PAD_START_AND_END'''
+    UNKNOWN = 'UNKNOWN'
+    '''UNKNOWN'''
+
+    def __reduce_ex__(self, proto):
+        return self.__class__, (self.name,)
+
+
+scout_compute_api_RangePaddingConfiguration.__name__ = "RangePaddingConfiguration"
+scout_compute_api_RangePaddingConfiguration.__qualname__ = "RangePaddingConfiguration"
+scout_compute_api_RangePaddingConfiguration.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_RangeSeries(ConjureUnionType):
     _approximate_threshold: Optional["scout_compute_api_ApproximateThresholdRanges"] = None
     _duration_filter: Optional["scout_compute_api_DurationFilterRanges"] = None
@@ -51904,6 +51985,7 @@ class scout_compute_api_RangeSeries(ConjureUnionType):
     _stale_range: Optional["scout_compute_api_StaleRanges"] = None
     _threshold: Optional["scout_compute_api_ThresholdingRanges"] = None
     _union_range: Optional["scout_compute_api_UnionRanges"] = None
+    _padded_ranges: Optional["scout_compute_api_PaddedRanges"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
@@ -51927,7 +52009,8 @@ class scout_compute_api_RangeSeries(ConjureUnionType):
             'stability_detection': ConjureFieldDefinition('stabilityDetection', scout_compute_api_StabilityDetectionRanges),
             'stale_range': ConjureFieldDefinition('staleRange', scout_compute_api_StaleRanges),
             'threshold': ConjureFieldDefinition('threshold', scout_compute_api_ThresholdingRanges),
-            'union_range': ConjureFieldDefinition('unionRange', scout_compute_api_UnionRanges)
+            'union_range': ConjureFieldDefinition('unionRange', scout_compute_api_UnionRanges),
+            'padded_ranges': ConjureFieldDefinition('paddedRanges', scout_compute_api_PaddedRanges)
         }
 
     def __init__(
@@ -51952,10 +52035,11 @@ class scout_compute_api_RangeSeries(ConjureUnionType):
             stale_range: Optional["scout_compute_api_StaleRanges"] = None,
             threshold: Optional["scout_compute_api_ThresholdingRanges"] = None,
             union_range: Optional["scout_compute_api_UnionRanges"] = None,
+            padded_ranges: Optional["scout_compute_api_PaddedRanges"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (approximate_threshold is not None) + (duration_filter is not None) + (enum_filter is not None) + (enum_series_equality_ranges_node is not None) + (events_search is not None) + (intersect_range is not None) + (literal_ranges is not None) + (min_max_threshold is not None) + (not_ is not None) + (on_change is not None) + (peak is not None) + (range_numeric_aggregation is not None) + (raw is not None) + (derived is not None) + (series_crossover_ranges_node is not None) + (series_equality_ranges_node is not None) + (stability_detection is not None) + (stale_range is not None) + (threshold is not None) + (union_range is not None) != 1:
+            if (approximate_threshold is not None) + (duration_filter is not None) + (enum_filter is not None) + (enum_series_equality_ranges_node is not None) + (events_search is not None) + (intersect_range is not None) + (literal_ranges is not None) + (min_max_threshold is not None) + (not_ is not None) + (on_change is not None) + (peak is not None) + (range_numeric_aggregation is not None) + (raw is not None) + (derived is not None) + (series_crossover_ranges_node is not None) + (series_equality_ranges_node is not None) + (stability_detection is not None) + (stale_range is not None) + (threshold is not None) + (union_range is not None) + (padded_ranges is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if approximate_threshold is not None:
@@ -52018,6 +52102,9 @@ class scout_compute_api_RangeSeries(ConjureUnionType):
             if union_range is not None:
                 self._union_range = union_range
                 self._type = 'unionRange'
+            if padded_ranges is not None:
+                self._padded_ranges = padded_ranges
+                self._type = 'paddedRanges'
 
         elif type_of_union == 'approximateThreshold':
             if approximate_threshold is None:
@@ -52119,6 +52206,11 @@ class scout_compute_api_RangeSeries(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._union_range = union_range
             self._type = 'unionRange'
+        elif type_of_union == 'paddedRanges':
+            if padded_ranges is None:
+                raise ValueError('a union value must not be None')
+            self._padded_ranges = padded_ranges
+            self._type = 'paddedRanges'
 
     @builtins.property
     def approximate_threshold(self) -> Optional["scout_compute_api_ApproximateThresholdRanges"]:
@@ -52204,6 +52296,10 @@ class scout_compute_api_RangeSeries(ConjureUnionType):
     def union_range(self) -> Optional["scout_compute_api_UnionRanges"]:
         return self._union_range
 
+    @builtins.property
+    def padded_ranges(self) -> Optional["scout_compute_api_PaddedRanges"]:
+        return self._padded_ranges
+
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, scout_compute_api_RangeSeriesVisitor):
             raise ValueError('{} is not an instance of scout_compute_api_RangeSeriesVisitor'.format(visitor.__class__.__name__))
@@ -52247,6 +52343,8 @@ class scout_compute_api_RangeSeries(ConjureUnionType):
             return visitor._threshold(self.threshold)
         if self._type == 'unionRange' and self.union_range is not None:
             return visitor._union_range(self.union_range)
+        if self._type == 'paddedRanges' and self.padded_ranges is not None:
+            return visitor._padded_ranges(self.padded_ranges)
 
 
 scout_compute_api_RangeSeries.__name__ = "RangeSeries"
@@ -52336,6 +52434,10 @@ class scout_compute_api_RangeSeriesVisitor:
     def _union_range(self, union_range: "scout_compute_api_UnionRanges") -> Any:
         pass
 
+    @abstractmethod
+    def _padded_ranges(self, padded_ranges: "scout_compute_api_PaddedRanges") -> Any:
+        pass
+
 
 scout_compute_api_RangeSeriesVisitor.__name__ = "RangeSeriesVisitor"
 scout_compute_api_RangeSeriesVisitor.__qualname__ = "RangeSeriesVisitor"
@@ -53207,40 +53309,52 @@ scout_compute_api_SelectNewestPointsSeries.__module__ = "nominal_api.scout_compu
 
 class scout_compute_api_SelectValue(ConjureUnionType):
     _first_point: Optional["scout_compute_api_Series"] = None
+    _first_value_point: Optional["scout_compute_api_Series"] = None
     _first_range: Optional["scout_compute_api_RangeSeries"] = None
     _last_point: Optional["scout_compute_api_Series"] = None
+    _last_value_point: Optional["scout_compute_api_Series"] = None
     _last_range: Optional["scout_compute_api_RangeSeries"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'first_point': ConjureFieldDefinition('firstPoint', scout_compute_api_Series),
+            'first_value_point': ConjureFieldDefinition('firstValuePoint', scout_compute_api_Series),
             'first_range': ConjureFieldDefinition('firstRange', scout_compute_api_RangeSeries),
             'last_point': ConjureFieldDefinition('lastPoint', scout_compute_api_Series),
+            'last_value_point': ConjureFieldDefinition('lastValuePoint', scout_compute_api_Series),
             'last_range': ConjureFieldDefinition('lastRange', scout_compute_api_RangeSeries)
         }
 
     def __init__(
             self,
             first_point: Optional["scout_compute_api_Series"] = None,
+            first_value_point: Optional["scout_compute_api_Series"] = None,
             first_range: Optional["scout_compute_api_RangeSeries"] = None,
             last_point: Optional["scout_compute_api_Series"] = None,
+            last_value_point: Optional["scout_compute_api_Series"] = None,
             last_range: Optional["scout_compute_api_RangeSeries"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (first_point is not None) + (first_range is not None) + (last_point is not None) + (last_range is not None) != 1:
+            if (first_point is not None) + (first_value_point is not None) + (first_range is not None) + (last_point is not None) + (last_value_point is not None) + (last_range is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if first_point is not None:
                 self._first_point = first_point
                 self._type = 'firstPoint'
+            if first_value_point is not None:
+                self._first_value_point = first_value_point
+                self._type = 'firstValuePoint'
             if first_range is not None:
                 self._first_range = first_range
                 self._type = 'firstRange'
             if last_point is not None:
                 self._last_point = last_point
                 self._type = 'lastPoint'
+            if last_value_point is not None:
+                self._last_value_point = last_value_point
+                self._type = 'lastValuePoint'
             if last_range is not None:
                 self._last_range = last_range
                 self._type = 'lastRange'
@@ -53250,6 +53364,11 @@ class scout_compute_api_SelectValue(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._first_point = first_point
             self._type = 'firstPoint'
+        elif type_of_union == 'firstValuePoint':
+            if first_value_point is None:
+                raise ValueError('a union value must not be None')
+            self._first_value_point = first_value_point
+            self._type = 'firstValuePoint'
         elif type_of_union == 'firstRange':
             if first_range is None:
                 raise ValueError('a union value must not be None')
@@ -53260,6 +53379,11 @@ class scout_compute_api_SelectValue(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._last_point = last_point
             self._type = 'lastPoint'
+        elif type_of_union == 'lastValuePoint':
+            if last_value_point is None:
+                raise ValueError('a union value must not be None')
+            self._last_value_point = last_value_point
+            self._type = 'lastValuePoint'
         elif type_of_union == 'lastRange':
             if last_range is None:
                 raise ValueError('a union value must not be None')
@@ -53270,6 +53394,10 @@ class scout_compute_api_SelectValue(ConjureUnionType):
     def first_point(self) -> Optional["scout_compute_api_Series"]:
         return self._first_point
 
+    @builtins.property
+    def first_value_point(self) -> Optional["scout_compute_api_Series"]:
+        return self._first_value_point
+
     @builtins.property
     def first_range(self) -> Optional["scout_compute_api_RangeSeries"]:
         return self._first_range
@@ -53278,6 +53406,10 @@ class scout_compute_api_SelectValue(ConjureUnionType):
     def last_point(self) -> Optional["scout_compute_api_Series"]:
         return self._last_point
 
+    @builtins.property
+    def last_value_point(self) -> Optional["scout_compute_api_Series"]:
+        return self._last_value_point
+
     @builtins.property
     def last_range(self) -> Optional["scout_compute_api_RangeSeries"]:
         return self._last_range
@@ -53287,10 +53419,14 @@ class scout_compute_api_SelectValue(ConjureUnionType):
             raise ValueError('{} is not an instance of scout_compute_api_SelectValueVisitor'.format(visitor.__class__.__name__))
         if self._type == 'firstPoint' and self.first_point is not None:
             return visitor._first_point(self.first_point)
+        if self._type == 'firstValuePoint' and self.first_value_point is not None:
+            return visitor._first_value_point(self.first_value_point)
         if self._type == 'firstRange' and self.first_range is not None:
             return visitor._first_range(self.first_range)
         if self._type == 'lastPoint' and self.last_point is not None:
             return visitor._last_point(self.last_point)
+        if self._type == 'lastValuePoint' and self.last_value_point is not None:
+            return visitor._last_value_point(self.last_value_point)
         if self._type == 'lastRange' and self.last_range is not None:
             return visitor._last_range(self.last_range)
 
@@ -53306,6 +53442,10 @@ class scout_compute_api_SelectValueVisitor:
     def _first_point(self, first_point: "scout_compute_api_Series") -> Any:
         pass
 
+    @abstractmethod
+    def _first_value_point(self, first_value_point: "scout_compute_api_Series") -> Any:
+        pass
+
     @abstractmethod
     def _first_range(self, first_range: "scout_compute_api_RangeSeries") -> Any:
         pass
@@ -53314,6 +53454,10 @@ class scout_compute_api_SelectValueVisitor:
     def _last_point(self, last_point: "scout_compute_api_Series") -> Any:
         pass
 
+    @abstractmethod
+    def _last_value_point(self, last_value_point: "scout_compute_api_Series") -> Any:
+        pass
+
     @abstractmethod
     def _last_range(self, last_range: "scout_compute_api_RangeSeries") -> Any:
         pass
@@ -53769,6 +53913,45 @@ scout_compute_api_SignalFilterSeries.__qualname__ = "SignalFilterSeries"
 scout_compute_api_SignalFilterSeries.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_SinglePoint(ConjureBeanType):
+    """A return type used for sending generic point value returns. Uses strings to pass Int64. 
+Precision loss is a warning that will be true if any of the referenced series are Int series and 
+the result is computed with casting values to doubles due to lack of ability to be done in clickhouse.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'timestamp': ConjureFieldDefinition('timestamp', api_Timestamp),
+            'value': ConjureFieldDefinition('value', scout_compute_api_Value),
+            'precision_loss': ConjureFieldDefinition('precisionLoss', bool)
+        }
+
+    __slots__: List[str] = ['_timestamp', '_value', '_precision_loss']
+
+    def __init__(self, precision_loss: bool, timestamp: "api_Timestamp", value: "scout_compute_api_Value") -> None:
+        self._timestamp = timestamp
+        self._value = value
+        self._precision_loss = precision_loss
+
+    @builtins.property
+    def timestamp(self) -> "api_Timestamp":
+        return self._timestamp
+
+    @builtins.property
+    def value(self) -> "scout_compute_api_Value":
+        return self._value
+
+    @builtins.property
+    def precision_loss(self) -> bool:
+        return self._precision_loss
+
+
+scout_compute_api_SinglePoint.__name__ = "SinglePoint"
+scout_compute_api_SinglePoint.__qualname__ = "SinglePoint"
+scout_compute_api_SinglePoint.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_SpatialDecimateStrategy(ConjureBeanType):
     """Decimate by spatial trees.
 Creates buckets by bisecting on each dimension, creating quadrants for 2d scatter and octants for 3d scatter.
@@ -55368,6 +55551,148 @@ scout_compute_api_UnitsMissing.__qualname__ = "UnitsMissing"
 scout_compute_api_UnitsMissing.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_Value(ConjureUnionType):
+    """A way to represent any general return value. Supports numeric, string, array, and struct returns.
+    """
+    _string_value: Optional[str] = None
+    _float64_value: Optional[float] = None
+    _int64_value: Optional[str] = None
+    _array_value: Optional[List[Optional["scout_compute_api_Value"]]] = None
+    _object_value: Optional[Dict[str, Optional["scout_compute_api_Value"]]] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'string_value': ConjureFieldDefinition('stringValue', str),
+            'float64_value': ConjureFieldDefinition('float64Value', float),
+            'int64_value': ConjureFieldDefinition('int64Value', str),
+            'array_value': ConjureFieldDefinition('arrayValue', List[OptionalTypeWrapper[scout_compute_api_Value]]),
+            'object_value': ConjureFieldDefinition('objectValue', Dict[str, OptionalTypeWrapper[scout_compute_api_Value]])
+        }
+
+    def __init__(
+            self,
+            string_value: Optional[str] = None,
+            float64_value: Optional[float] = None,
+            int64_value: Optional[str] = None,
+            array_value: Optional[List[Optional["scout_compute_api_Value"]]] = None,
+            object_value: Optional[Dict[str, Optional["scout_compute_api_Value"]]] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (string_value is not None) + (float64_value is not None) + (int64_value is not None) + (array_value is not None) + (object_value is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if string_value is not None:
+                self._string_value = string_value
+                self._type = 'stringValue'
+            if float64_value is not None:
+                self._float64_value = float64_value
+                self._type = 'float64Value'
+            if int64_value is not None:
+                self._int64_value = int64_value
+                self._type = 'int64Value'
+            if array_value is not None:
+                self._array_value = array_value
+                self._type = 'arrayValue'
+            if object_value is not None:
+                self._object_value = object_value
+                self._type = 'objectValue'
+
+        elif type_of_union == 'stringValue':
+            if string_value is None:
+                raise ValueError('a union value must not be None')
+            self._string_value = string_value
+            self._type = 'stringValue'
+        elif type_of_union == 'float64Value':
+            if float64_value is None:
+                raise ValueError('a union value must not be None')
+            self._float64_value = float64_value
+            self._type = 'float64Value'
+        elif type_of_union == 'int64Value':
+            if int64_value is None:
+                raise ValueError('a union value must not be None')
+            self._int64_value = int64_value
+            self._type = 'int64Value'
+        elif type_of_union == 'arrayValue':
+            if array_value is None:
+                raise ValueError('a union value must not be None')
+            self._array_value = array_value
+            self._type = 'arrayValue'
+        elif type_of_union == 'objectValue':
+            if object_value is None:
+                raise ValueError('a union value must not be None')
+            self._object_value = object_value
+            self._type = 'objectValue'
+
+    @builtins.property
+    def string_value(self) -> Optional[str]:
+        return self._string_value
+
+    @builtins.property
+    def float64_value(self) -> Optional[float]:
+        return self._float64_value
+
+    @builtins.property
+    def int64_value(self) -> Optional[str]:
+        return self._int64_value
+
+    @builtins.property
+    def array_value(self) -> Optional[List[Optional["scout_compute_api_Value"]]]:
+        return self._array_value
+
+    @builtins.property
+    def object_value(self) -> Optional[Dict[str, Optional["scout_compute_api_Value"]]]:
+        return self._object_value
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_compute_api_ValueVisitor):
+            raise ValueError('{} is not an instance of scout_compute_api_ValueVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'stringValue' and self.string_value is not None:
+            return visitor._string_value(self.string_value)
+        if self._type == 'float64Value' and self.float64_value is not None:
+            return visitor._float64_value(self.float64_value)
+        if self._type == 'int64Value' and self.int64_value is not None:
+            return visitor._int64_value(self.int64_value)
+        if self._type == 'arrayValue' and self.array_value is not None:
+            return visitor._array_value(self.array_value)
+        if self._type == 'objectValue' and self.object_value is not None:
+            return visitor._object_value(self.object_value)
+
+
+scout_compute_api_Value.__name__ = "Value"
+scout_compute_api_Value.__qualname__ = "Value"
+scout_compute_api_Value.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_ValueVisitor:
+
+    @abstractmethod
+    def _string_value(self, string_value: str) -> Any:
+        pass
+
+    @abstractmethod
+    def _float64_value(self, float64_value: float) -> Any:
+        pass
+
+    @abstractmethod
+    def _int64_value(self, int64_value: str) -> Any:
+        pass
+
+    @abstractmethod
+    def _array_value(self, array_value: List[Optional["scout_compute_api_Value"]]) -> Any:
+        pass
+
+    @abstractmethod
+    def _object_value(self, object_value: Dict[str, Optional["scout_compute_api_Value"]]) -> Any:
+        pass
+
+
+scout_compute_api_ValueVisitor.__name__ = "ValueVisitor"
+scout_compute_api_ValueVisitor.__qualname__ = "ValueVisitor"
+scout_compute_api_ValueVisitor.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_ValueDifferenceSeries(ConjureBeanType):
     """Outputs a new series where each value is the difference between the values of the current and previous point.
     """
@@ -55446,6 +55771,24 @@ scout_compute_api_ValueMapSeries.__qualname__ = "ValueMapSeries"
 scout_compute_api_ValueMapSeries.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_ValueStrategy(ConjureEnumType):
+
+    FIRST = 'FIRST'
+    '''FIRST'''
+    LAST = 'LAST'
+    '''LAST'''
+    UNKNOWN = 'UNKNOWN'
+    '''UNKNOWN'''
+
+    def __reduce_ex__(self, proto):
+        return self.__class__, (self.name,)
+
+
+scout_compute_api_ValueStrategy.__name__ = "ValueStrategy"
+scout_compute_api_ValueStrategy.__qualname__ = "ValueStrategy"
+scout_compute_api_ValueStrategy.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_VariableValue(ConjureUnionType):
     _double: Optional[float] = None
     _compute_node: Optional["scout_compute_api_ComputeNodeWithContext"] = None
@@ -61684,6 +62027,41 @@ scout_compute_resolved_api_OnChangeRangesNode.__qualname__ = "OnChangeRangesNode
 scout_compute_resolved_api_OnChangeRangesNode.__module__ = "nominal_api.scout_compute_resolved_api"
 
 
+class scout_compute_resolved_api_PaddedRangesNode(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'input': ConjureFieldDefinition('input', scout_compute_resolved_api_RangesNode),
+            'padding': ConjureFieldDefinition('padding', scout_run_api_Duration),
+            'padding_configuration': ConjureFieldDefinition('paddingConfiguration', scout_compute_api_RangePaddingConfiguration)
+        }
+
+    __slots__: List[str] = ['_input', '_padding', '_padding_configuration']
+
+    def __init__(self, input: "scout_compute_resolved_api_RangesNode", padding: "scout_run_api_Duration", padding_configuration: "scout_compute_api_RangePaddingConfiguration") -> None:
+        self._input = input
+        self._padding = padding
+        self._padding_configuration = padding_configuration
+
+    @builtins.property
+    def input(self) -> "scout_compute_resolved_api_RangesNode":
+        return self._input
+
+    @builtins.property
+    def padding(self) -> "scout_run_api_Duration":
+        return self._padding
+
+    @builtins.property
+    def padding_configuration(self) -> "scout_compute_api_RangePaddingConfiguration":
+        return self._padding_configuration
+
+
+scout_compute_resolved_api_PaddedRangesNode.__name__ = "PaddedRangesNode"
+scout_compute_resolved_api_PaddedRangesNode.__qualname__ = "PaddedRangesNode"
+scout_compute_resolved_api_PaddedRangesNode.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
 class scout_compute_resolved_api_PercentageThreshold(ConjureBeanType):
 
     @builtins.classmethod
@@ -61897,6 +62275,7 @@ class scout_compute_resolved_api_RangesNode(ConjureUnionType):
     _threshold: Optional["scout_compute_resolved_api_ThresholdingRangesNode"] = None
     _union_range: Optional["scout_compute_resolved_api_UnionRangesNode"] = None
     _event_search: Optional["scout_compute_resolved_api_EventSearchNode"] = None
+    _padded_ranges: Optional["scout_compute_resolved_api_PaddedRangesNode"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
@@ -61916,7 +62295,8 @@ class scout_compute_resolved_api_RangesNode(ConjureUnionType):
             'stability_detection': ConjureFieldDefinition('stabilityDetection', scout_compute_resolved_api_StabilityDetectionRangesNode),
             'threshold': ConjureFieldDefinition('threshold', scout_compute_resolved_api_ThresholdingRangesNode),
             'union_range': ConjureFieldDefinition('unionRange', scout_compute_resolved_api_UnionRangesNode),
-            'event_search': ConjureFieldDefinition('eventSearch', scout_compute_resolved_api_EventSearchNode)
+            'event_search': ConjureFieldDefinition('eventSearch', scout_compute_resolved_api_EventSearchNode),
+            'padded_ranges': ConjureFieldDefinition('paddedRanges', scout_compute_resolved_api_PaddedRangesNode)
         }
 
     def __init__(
@@ -61937,10 +62317,11 @@ class scout_compute_resolved_api_RangesNode(ConjureUnionType):
             threshold: Optional["scout_compute_resolved_api_ThresholdingRangesNode"] = None,
             union_range: Optional["scout_compute_resolved_api_UnionRangesNode"] = None,
             event_search: Optional["scout_compute_resolved_api_EventSearchNode"] = None,
+            padded_ranges: Optional["scout_compute_resolved_api_PaddedRangesNode"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (duration_filter is not None) + (enum_equality is not None) + (enum_filter is not None) + (extrema is not None) + (intersect_range is not None) + (literal_ranges is not None) + (min_max_threshold is not None) + (not_ is not None) + (on_change is not None) + (range_numeric_aggregation is not None) + (series_crossover_ranges_node is not None) + (stale_range is not None) + (stability_detection is not None) + (threshold is not None) + (union_range is not None) + (event_search is not None) != 1:
+            if (duration_filter is not None) + (enum_equality is not None) + (enum_filter is not None) + (extrema is not None) + (intersect_range is not None) + (literal_ranges is not None) + (min_max_threshold is not None) + (not_ is not None) + (on_change is not None) + (range_numeric_aggregation is not None) + (series_crossover_ranges_node is not None) + (stale_range is not None) + (stability_detection is not None) + (threshold is not None) + (union_range is not None) + (event_search is not None) + (padded_ranges is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if duration_filter is not None:
@@ -61991,6 +62372,9 @@ class scout_compute_resolved_api_RangesNode(ConjureUnionType):
             if event_search is not None:
                 self._event_search = event_search
                 self._type = 'eventSearch'
+            if padded_ranges is not None:
+                self._padded_ranges = padded_ranges
+                self._type = 'paddedRanges'
 
         elif type_of_union == 'durationFilter':
             if duration_filter is None:
@@ -62072,6 +62456,11 @@ class scout_compute_resolved_api_RangesNode(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._event_search = event_search
             self._type = 'eventSearch'
+        elif type_of_union == 'paddedRanges':
+            if padded_ranges is None:
+                raise ValueError('a union value must not be None')
+            self._padded_ranges = padded_ranges
+            self._type = 'paddedRanges'
 
     @builtins.property
     def duration_filter(self) -> Optional["scout_compute_resolved_api_DurationFilterRangesNode"]:
@@ -62137,6 +62526,10 @@ class scout_compute_resolved_api_RangesNode(ConjureUnionType):
     def event_search(self) -> Optional["scout_compute_resolved_api_EventSearchNode"]:
         return self._event_search
 
+    @builtins.property
+    def padded_ranges(self) -> Optional["scout_compute_resolved_api_PaddedRangesNode"]:
+        return self._padded_ranges
+
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, scout_compute_resolved_api_RangesNodeVisitor):
             raise ValueError('{} is not an instance of scout_compute_resolved_api_RangesNodeVisitor'.format(visitor.__class__.__name__))
@@ -62172,6 +62565,8 @@ class scout_compute_resolved_api_RangesNode(ConjureUnionType):
             return visitor._union_range(self.union_range)
         if self._type == 'eventSearch' and self.event_search is not None:
             return visitor._event_search(self.event_search)
+        if self._type == 'paddedRanges' and self.padded_ranges is not None:
+            return visitor._padded_ranges(self.padded_ranges)
 
 
 scout_compute_resolved_api_RangesNode.__name__ = "RangesNode"
@@ -62245,6 +62640,10 @@ class scout_compute_resolved_api_RangesNodeVisitor:
     def _event_search(self, event_search: "scout_compute_resolved_api_EventSearchNode") -> Any:
         pass
 
+    @abstractmethod
+    def _padded_ranges(self, padded_ranges: "scout_compute_resolved_api_PaddedRangesNode") -> Any:
+        pass
+
 
 scout_compute_resolved_api_RangesNodeVisitor.__name__ = "RangesNodeVisitor"
 scout_compute_resolved_api_RangesNodeVisitor.__qualname__ = "RangesNodeVisitor"
@@ -63151,40 +63550,52 @@ scout_compute_resolved_api_SelectNewestPointsSeriesNode.__module__ = "nominal_ap
 
 class scout_compute_resolved_api_SelectValueNode(ConjureUnionType):
     _first_point: Optional["scout_compute_resolved_api_SeriesNode"] = None
+    _first_value_point: Optional["scout_compute_resolved_api_SeriesNode"] = None
     _first_range: Optional["scout_compute_resolved_api_RangesNode"] = None
     _last_point: Optional["scout_compute_resolved_api_SeriesNode"] = None
+    _last_value_point: Optional["scout_compute_resolved_api_SeriesNode"] = None
     _last_range: Optional["scout_compute_resolved_api_RangesNode"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'first_point': ConjureFieldDefinition('firstPoint', scout_compute_resolved_api_SeriesNode),
+            'first_value_point': ConjureFieldDefinition('firstValuePoint', scout_compute_resolved_api_SeriesNode),
             'first_range': ConjureFieldDefinition('firstRange', scout_compute_resolved_api_RangesNode),
             'last_point': ConjureFieldDefinition('lastPoint', scout_compute_resolved_api_SeriesNode),
+            'last_value_point': ConjureFieldDefinition('lastValuePoint', scout_compute_resolved_api_SeriesNode),
             'last_range': ConjureFieldDefinition('lastRange', scout_compute_resolved_api_RangesNode)
         }
 
     def __init__(
             self,
             first_point: Optional["scout_compute_resolved_api_SeriesNode"] = None,
+            first_value_point: Optional["scout_compute_resolved_api_SeriesNode"] = None,
             first_range: Optional["scout_compute_resolved_api_RangesNode"] = None,
             last_point: Optional["scout_compute_resolved_api_SeriesNode"] = None,
+            last_value_point: Optional["scout_compute_resolved_api_SeriesNode"] = None,
             last_range: Optional["scout_compute_resolved_api_RangesNode"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (first_point is not None) + (first_range is not None) + (last_point is not None) + (last_range is not None) != 1:
+            if (first_point is not None) + (first_value_point is not None) + (first_range is not None) + (last_point is not None) + (last_value_point is not None) + (last_range is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if first_point is not None:
                 self._first_point = first_point
                 self._type = 'firstPoint'
+            if first_value_point is not None:
+                self._first_value_point = first_value_point
+                self._type = 'firstValuePoint'
             if first_range is not None:
                 self._first_range = first_range
                 self._type = 'firstRange'
             if last_point is not None:
                 self._last_point = last_point
                 self._type = 'lastPoint'
+            if last_value_point is not None:
+                self._last_value_point = last_value_point
+                self._type = 'lastValuePoint'
             if last_range is not None:
                 self._last_range = last_range
                 self._type = 'lastRange'
@@ -63194,6 +63605,11 @@ class scout_compute_resolved_api_SelectValueNode(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._first_point = first_point
             self._type = 'firstPoint'
+        elif type_of_union == 'firstValuePoint':
+            if first_value_point is None:
+                raise ValueError('a union value must not be None')
+            self._first_value_point = first_value_point
+            self._type = 'firstValuePoint'
         elif type_of_union == 'firstRange':
             if first_range is None:
                 raise ValueError('a union value must not be None')
@@ -63204,6 +63620,11 @@ class scout_compute_resolved_api_SelectValueNode(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._last_point = last_point
             self._type = 'lastPoint'
+        elif type_of_union == 'lastValuePoint':
+            if last_value_point is None:
+                raise ValueError('a union value must not be None')
+            self._last_value_point = last_value_point
+            self._type = 'lastValuePoint'
         elif type_of_union == 'lastRange':
             if last_range is None:
                 raise ValueError('a union value must not be None')
@@ -63214,6 +63635,10 @@ class scout_compute_resolved_api_SelectValueNode(ConjureUnionType):
     def first_point(self) -> Optional["scout_compute_resolved_api_SeriesNode"]:
         return self._first_point
 
+    @builtins.property
+    def first_value_point(self) -> Optional["scout_compute_resolved_api_SeriesNode"]:
+        return self._first_value_point
+
     @builtins.property
     def first_range(self) -> Optional["scout_compute_resolved_api_RangesNode"]:
         return self._first_range
@@ -63222,6 +63647,10 @@ class scout_compute_resolved_api_SelectValueNode(ConjureUnionType):
     def last_point(self) -> Optional["scout_compute_resolved_api_SeriesNode"]:
         return self._last_point
 
+    @builtins.property
+    def last_value_point(self) -> Optional["scout_compute_resolved_api_SeriesNode"]:
+        return self._last_value_point
+
     @builtins.property
     def last_range(self) -> Optional["scout_compute_resolved_api_RangesNode"]:
         return self._last_range
@@ -63231,10 +63660,14 @@ class scout_compute_resolved_api_SelectValueNode(ConjureUnionType):
             raise ValueError('{} is not an instance of scout_compute_resolved_api_SelectValueNodeVisitor'.format(visitor.__class__.__name__))
         if self._type == 'firstPoint' and self.first_point is not None:
             return visitor._first_point(self.first_point)
+        if self._type == 'firstValuePoint' and self.first_value_point is not None:
+            return visitor._first_value_point(self.first_value_point)
         if self._type == 'firstRange' and self.first_range is not None:
             return visitor._first_range(self.first_range)
         if self._type == 'lastPoint' and self.last_point is not None:
             return visitor._last_point(self.last_point)
+        if self._type == 'lastValuePoint' and self.last_value_point is not None:
+            return visitor._last_value_point(self.last_value_point)
         if self._type == 'lastRange' and self.last_range is not None:
             return visitor._last_range(self.last_range)
 
@@ -63250,6 +63683,10 @@ class scout_compute_resolved_api_SelectValueNodeVisitor:
     def _first_point(self, first_point: "scout_compute_resolved_api_SeriesNode") -> Any:
         pass
 
+    @abstractmethod
+    def _first_value_point(self, first_value_point: "scout_compute_resolved_api_SeriesNode") -> Any:
+        pass
+
     @abstractmethod
     def _first_range(self, first_range: "scout_compute_resolved_api_RangesNode") -> Any:
         pass
@@ -63258,6 +63695,10 @@ class scout_compute_resolved_api_SelectValueNodeVisitor:
     def _last_point(self, last_point: "scout_compute_resolved_api_SeriesNode") -> Any:
         pass
 
+    @abstractmethod
+    def _last_value_point(self, last_value_point: "scout_compute_resolved_api_SeriesNode") -> Any:
+        pass
+
     @abstractmethod
     def _last_range(self, last_range: "scout_compute_resolved_api_RangesNode") -> Any:
         pass

nominal_api/scout_compute_api/__init__.py

@@ -248,6 +248,7 @@ from .._impl import (
     scout_compute_api_OutputFormat as OutputFormat,
     scout_compute_api_OutputRangeStart as OutputRangeStart,
     scout_compute_api_OutputRangeStartVisitor as OutputRangeStartVisitor,
+    scout_compute_api_PaddedRanges as PaddedRanges,
     scout_compute_api_PageInfo as PageInfo,
     scout_compute_api_PageStrategy as PageStrategy,
     scout_compute_api_PageStrategyVisitor as PageStrategyVisitor,
@@ -279,6 +280,7 @@ from .._impl import (
     scout_compute_api_RangeAggregationOperation as RangeAggregationOperation,
     scout_compute_api_RangeAggregationOperationVisitor as RangeAggregationOperationVisitor,
     scout_compute_api_RangeMap as RangeMap,
+    scout_compute_api_RangePaddingConfiguration as RangePaddingConfiguration,
     scout_compute_api_RangeSeries as RangeSeries,
     scout_compute_api_RangeSeriesVisitor as RangeSeriesVisitor,
     scout_compute_api_RangeSummary as RangeSummary,
@@ -314,6 +316,7 @@ from .._impl import (
     scout_compute_api_SignalFilterConfiguration as SignalFilterConfiguration,
     scout_compute_api_SignalFilterConfigurationVisitor as SignalFilterConfigurationVisitor,
     scout_compute_api_SignalFilterSeries as SignalFilterSeries,
+    scout_compute_api_SinglePoint as SinglePoint,
     scout_compute_api_SpatialDecimateStrategy as SpatialDecimateStrategy,
     scout_compute_api_StabilityDetectionRanges as StabilityDetectionRanges,
     scout_compute_api_StabilityWindowConfiguration as StabilityWindowConfiguration,
@@ -360,8 +363,11 @@ from .._impl import (
     scout_compute_api_UnitResult as UnitResult,
     scout_compute_api_UnitResultVisitor as UnitResultVisitor,
     scout_compute_api_UnitsMissing as UnitsMissing,
+    scout_compute_api_Value as Value,
     scout_compute_api_ValueDifferenceSeries as ValueDifferenceSeries,
     scout_compute_api_ValueMapSeries as ValueMapSeries,
+    scout_compute_api_ValueStrategy as ValueStrategy,
+    scout_compute_api_ValueVisitor as ValueVisitor,
     scout_compute_api_VariableName as VariableName,
     scout_compute_api_VariableValue as VariableValue,
     scout_compute_api_VariableValueVisitor as VariableValueVisitor,
@@ -617,6 +623,7 @@ __all__ = [
     'OutputFormat',
     'OutputRangeStart',
     'OutputRangeStartVisitor',
+    'PaddedRanges',
     'PageInfo',
     'PageStrategy',
     'PageStrategyVisitor',
@@ -648,6 +655,7 @@ __all__ = [
     'RangeAggregationOperation',
     'RangeAggregationOperationVisitor',
     'RangeMap',
+    'RangePaddingConfiguration',
     'RangeSeries',
     'RangeSeriesVisitor',
     'RangeSummary',
@@ -683,6 +691,7 @@ __all__ = [
     'SignalFilterConfiguration',
     'SignalFilterConfigurationVisitor',
     'SignalFilterSeries',
+    'SinglePoint',
     'SpatialDecimateStrategy',
     'StabilityDetectionRanges',
     'StabilityWindowConfiguration',
@@ -729,8 +738,11 @@ __all__ = [
     'UnitResult',
     'UnitResultVisitor',
     'UnitsMissing',
+    'Value',
+    'ValueVisitor',
     'ValueDifferenceSeries',
     'ValueMapSeries',
+    'ValueStrategy',
     'VariableName',
     'VariableValue',
     'VariableValueVisitor',

nominal_api/scout_compute_resolved_api/__init__.py

@@ -96,6 +96,7 @@ from .._impl import (
     scout_compute_resolved_api_NumericUnionSeriesNode as NumericUnionSeriesNode,
     scout_compute_resolved_api_OffsetSeriesNode as OffsetSeriesNode,
     scout_compute_resolved_api_OnChangeRangesNode as OnChangeRangesNode,
+    scout_compute_resolved_api_PaddedRangesNode as PaddedRangesNode,
     scout_compute_resolved_api_PercentageThreshold as PercentageThreshold,
     scout_compute_resolved_api_PeriodogramNode as PeriodogramNode,
     scout_compute_resolved_api_PersistenceWindowConfiguration as PersistenceWindowConfiguration,
@@ -261,6 +262,7 @@ __all__ = [
     'NumericUnionSeriesNode',
     'OffsetSeriesNode',
     'OnChangeRangesNode',
+    'PaddedRangesNode',
     'PercentageThreshold',
     'PeriodogramNode',
     'PersistenceWindowConfiguration',

{nominal_api-0.914.0.dist-info → nominal_api-0.916.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nominal-api
-Version: 0.914.0
+Version: 0.916.0
 Requires-Python: >=3.8
 Requires-Dist: requests
 Requires-Dist: conjure-python-client<4,>=2.8.0

{nominal_api-0.914.0.dist-info → nominal_api-0.916.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
-nominal_api/__init__.py,sha256=tLXxgQoFiNcX063_L1YKUTmxifja1VOk7p8NEehiZsY,2088
-nominal_api/_impl.py,sha256=azQJBINSPHx7uiAH5Sp_V2H7-sc3pjzgz250zPy2bn0,3783961
+nominal_api/__init__.py,sha256=CW7_BZ2UZur65R2DO7-trm3Od1m-D2s0LQQiYWKANyE,2088
+nominal_api/_impl.py,sha256=AjBv5B5INxbs6ALEonHSJaUr4wtadDlBrpRMKYemHE0,3803671
 nominal_api/py.typed,sha256=eoZ6GfifbqhMLNzjlqRDVil-yyBkOmVN9ujSgJWNBlY,15
 nominal_api/api/__init__.py,sha256=GqRLE9wwPPQgALVHFJViG8E4JJ2t3yfHedeXRLu1L70,2226
 nominal_api/api_ids/__init__.py,sha256=sxqN5dMk6bOx0SKOd0ANG3_kmx1VtdSVotzEGn_q6sE,114
@@ -33,9 +33,9 @@ nominal_api/scout_checklistexecution_api/__init__.py,sha256=iVeUjPTlbpQ3vlQkQjHr
 nominal_api/scout_checks_api/__init__.py,sha256=uCmiNrVwLDlkg8YnpP-uZr9nFFFN52sM644Qo6YNy3k,6972
 nominal_api/scout_comparisonnotebook_api/__init__.py,sha256=F5cQo_KqeTpFwqKBDV-iEjrND7xQgkycC1yocpxq1Qk,6277
 nominal_api/scout_comparisonrun_api/__init__.py,sha256=y5SlDoXvskyTKjg2O8o3cBhGSN-KA7iVlVjyy3vb3Co,652
-nominal_api/scout_compute_api/__init__.py,sha256=wA_6Ip0rmGqS1Q3hS4NtyZJnak4tZ8rdisvUFK-BLVE,33751
+nominal_api/scout_compute_api/__init__.py,sha256=vxL3b1fqF9GUMWMHmn1hRhchcrBbgXMilNbyDMZgZNY,34201
 nominal_api/scout_compute_api_deprecated/__init__.py,sha256=JrZKbt1ulYECTdUSkXn6On22Alu_cPUBjCRWTN3ctxk,5041
-nominal_api/scout_compute_resolved_api/__init__.py,sha256=hPqFEk6hpnBiD8FYg-bxzFIeQtdhMOD__Ars5xcqtUo,17608
+nominal_api/scout_compute_resolved_api/__init__.py,sha256=cnh00fuFDRDg5aH3R1_iBomncmzGv0lM7-evSNvNIOk,17701
 nominal_api/scout_dataexport_api/__init__.py,sha256=E5hE8rqLbdCH1n877yLh_NjpP1RkJOWgqesH-ObhK1o,2122
 nominal_api/scout_datareview_api/__init__.py,sha256=ITQR6pdPseU9vS2bKDeleafiBhurtHmcHeKz_6J8Ab8,12229
 nominal_api/scout_datasource/__init__.py,sha256=Z1Msu1Daf8GlLuM3w5imyB-6DhTNZojxI6xpH1sSvhM,141
@@ -78,7 +78,7 @@ nominal_api/timeseries_seriescache/__init__.py,sha256=hL5hN8jKLEGE_fDiZzdASmWIrR
 nominal_api/timeseries_seriescache_api/__init__.py,sha256=USBxFmNnVFdnhTPLvWi3UgsvBZ4Iz4ycNgBTi10F-zI,1603
 nominal_api/upload_api/__init__.py,sha256=7-XXuZUqKPV4AMWvxNpZPZ5vBun4x-AomXj3Vol_BN4,123
 nominal_api/usercreation_api/__init__.py,sha256=Q6M70SlKFVfIxZqRohD4XYmBz5t2DP1DB0a0Q6glqGA,171
-nominal_api-0.914.0.dist-info/METADATA,sha256=fUQnq3nx9AGx5KuDwOkWEWaauRwEwRfJx-aHTP_cM_I,199
-nominal_api-0.914.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nominal_api-0.914.0.dist-info/top_level.txt,sha256=gI1ZdNJbuHcJZeKtCzzBXsEtpU1GX6XJKs6ksi_gCRA,12
-nominal_api-0.914.0.dist-info/RECORD,,
+nominal_api-0.916.0.dist-info/METADATA,sha256=B0NxZGb8e8YQQj-zV0afzzhkVvh6GIsmrCw3g7xeHmc,199
+nominal_api-0.916.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nominal_api-0.916.0.dist-info/top_level.txt,sha256=gI1ZdNJbuHcJZeKtCzzBXsEtpU1GX6XJKs6ksi_gCRA,12
+nominal_api-0.916.0.dist-info/RECORD,,