nominal-api 0.550.1__py3-none-any.whl → 0.551.0__py3-none-any.whl

nominal_api/_impl.py

@@ -22143,7 +22143,7 @@ class scout_checks_api_CheckJobSpec(ConjureBeanType):
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'data_review_rid': ConjureFieldDefinition('dataReviewRid', scout_datareview_api_DataReviewRid),
+            'data_review_rid': ConjureFieldDefinition('dataReviewRid', scout_rids_api_DataReviewRid),
             'check_rid': ConjureFieldDefinition('checkRid', scout_rids_api_CheckRid),
             'run_rid': ConjureFieldDefinition('runRid', OptionalTypeWrapper[scout_run_api_RunRid]),
             'check_implementation_index': ConjureFieldDefinition('checkImplementationIndex', OptionalTypeWrapper[int]),
@@ -23548,7 +23548,7 @@ class scout_checks_api_DeprecatedCheckJobSpec(ConjureBeanType):
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'data_review_rid': ConjureFieldDefinition('dataReviewRid', scout_datareview_api_DataReviewRid),
+            'data_review_rid': ConjureFieldDefinition('dataReviewRid', scout_rids_api_DataReviewRid),
             'check_rid': ConjureFieldDefinition('checkRid', scout_rids_api_CheckRid),
             'check_evaluation_rid': ConjureFieldDefinition('checkEvaluationRid', scout_datareview_api_AutomaticCheckEvaluationRid),
             'check_condition': ConjureFieldDefinition('checkCondition', scout_checks_api_CheckCondition),
@@ -27686,7 +27686,7 @@ class scout_compute_api_AssetChannel(ConjureBeanType):
         """
         Tags to filter the channel by, in addition to tag filters defined for a given Asset data scope. Throws on 
 collisions with tag keys already defined for the given Asset data scope. Only returns points that match 
-both sets of tag filters.
+both sets of tag filters. For log series, include arg filters here in addition to tag filters.
         """
         return self._additional_tags
 
@@ -30069,7 +30069,7 @@ class scout_compute_api_DataSourceChannel(ConjureBeanType):
     def tags(self) -> Dict[str, "scout_compute_api_StringConstant"]:
         """
         Tags to filter the channel by. Only returns points from the channel with matching tag values for the 
-provided tag keys.
+provided tag keys. For log series, include arg filters here in addition to tag filters.
         """
         return self._tags
 
@@ -32153,30 +32153,92 @@ scout_compute_api_LatLongPoint.__qualname__ = "LatLongPoint"
 scout_compute_api_LatLongPoint.__module__ = "nominal_api.scout_compute_api"
 
 
-class scout_compute_api_LogArgFilterOperator(ConjureBeanType):
+class scout_compute_api_LogFilterOperator(ConjureUnionType):
+    _regex_filter: Optional["scout_compute_api_LogRegexFilterOperator"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'regex_filter': ConjureFieldDefinition('regexFilter', scout_compute_api_LogRegexFilterOperator)
+        }
+
+    def __init__(
+            self,
+            regex_filter: Optional["scout_compute_api_LogRegexFilterOperator"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (regex_filter is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if regex_filter is not None:
+                self._regex_filter = regex_filter
+                self._type = 'regexFilter'
+
+        elif type_of_union == 'regexFilter':
+            if regex_filter is None:
+                raise ValueError('a union value must not be None')
+            self._regex_filter = regex_filter
+            self._type = 'regexFilter'
+
+    @builtins.property
+    def regex_filter(self) -> Optional["scout_compute_api_LogRegexFilterOperator"]:
+        return self._regex_filter
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_compute_api_LogFilterOperatorVisitor):
+            raise ValueError('{} is not an instance of scout_compute_api_LogFilterOperatorVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'regexFilter' and self.regex_filter is not None:
+            return visitor._regex_filter(self.regex_filter)
+
+
+scout_compute_api_LogFilterOperator.__name__ = "LogFilterOperator"
+scout_compute_api_LogFilterOperator.__qualname__ = "LogFilterOperator"
+scout_compute_api_LogFilterOperator.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_LogFilterOperatorVisitor:
+
+    @abstractmethod
+    def _regex_filter(self, regex_filter: "scout_compute_api_LogRegexFilterOperator") -> Any:
+        pass
+
+
+scout_compute_api_LogFilterOperatorVisitor.__name__ = "LogFilterOperatorVisitor"
+scout_compute_api_LogFilterOperatorVisitor.__qualname__ = "LogFilterOperatorVisitor"
+scout_compute_api_LogFilterOperatorVisitor.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_LogFilterSeries(ConjureBeanType):
     """
-    Outputs a new series where the log message in each point contains all of the given arg key-value pairs.
+    Outputs only values of the log plot that satisfy the filter.
     """
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'args': ConjureFieldDefinition('args', Dict[str, scout_compute_api_StringConstant])
+            'input': ConjureFieldDefinition('input', scout_compute_api_LogSeries),
+            'operator': ConjureFieldDefinition('operator', scout_compute_api_LogFilterOperator)
         }
 
-    __slots__: List[str] = ['_args']
+    __slots__: List[str] = ['_input', '_operator']
 
-    def __init__(self, args: Dict[str, "scout_compute_api_StringConstant"]) -> None:
-        self._args = args
+    def __init__(self, input: "scout_compute_api_LogSeries", operator: "scout_compute_api_LogFilterOperator") -> None:
+        self._input = input
+        self._operator = operator
 
     @builtins.property
-    def args(self) -> Dict[str, "scout_compute_api_StringConstant"]:
-        return self._args
+    def input(self) -> "scout_compute_api_LogSeries":
+        return self._input
+
+    @builtins.property
+    def operator(self) -> "scout_compute_api_LogFilterOperator":
+        return self._operator
 
 
-scout_compute_api_LogArgFilterOperator.__name__ = "LogArgFilterOperator"
-scout_compute_api_LogArgFilterOperator.__qualname__ = "LogArgFilterOperator"
-scout_compute_api_LogArgFilterOperator.__module__ = "nominal_api.scout_compute_api"
+scout_compute_api_LogFilterSeries.__name__ = "LogFilterSeries"
+scout_compute_api_LogFilterSeries.__qualname__ = "LogFilterSeries"
+scout_compute_api_LogFilterSeries.__module__ = "nominal_api.scout_compute_api"
 
 
 class scout_compute_api_LogPlot(ConjureBeanType):
@@ -32239,23 +32301,23 @@ scout_compute_api_LogPoint.__module__ = "nominal_api.scout_compute_api"
 
 class scout_compute_api_LogRegexFilterOperator(ConjureBeanType):
     """
-    Outputs a new series where the log message in each point satisfies the given re2 regular expression filter.
+    Filters points such that the log message in each point satisfies the given re2 regular expression filter.
 Regular expression syntax: https://github.com/google/re2/wiki/Syntax.
     """
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'regex': ConjureFieldDefinition('regex', scout_compute_api_StringConstant)
+            'regex': ConjureFieldDefinition('regex', str)
         }
 
     __slots__: List[str] = ['_regex']
 
-    def __init__(self, regex: "scout_compute_api_StringConstant") -> None:
+    def __init__(self, regex: str) -> None:
         self._regex = regex
 
     @builtins.property
-    def regex(self) -> "scout_compute_api_StringConstant":
+    def regex(self) -> str:
         return self._regex
 
 
@@ -32267,31 +32329,31 @@ scout_compute_api_LogRegexFilterOperator.__module__ = "nominal_api.scout_compute
 class scout_compute_api_LogSeries(ConjureUnionType):
     _raw: Optional["scout_compute_api_Reference"] = None
     _channel: Optional["scout_compute_api_ChannelSeries"] = None
-    _time_range_filter: Optional["scout_compute_api_LogTimeRangeFilterSeries"] = None
     _union: Optional["scout_compute_api_LogUnionSeries"] = None
-    _value_filter: Optional["scout_compute_api_LogValueFilterSeries"] = None
+    _filter: Optional["scout_compute_api_LogFilterSeries"] = None
+    _time_shift: Optional["scout_compute_api_LogTimeShiftSeries"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'raw': ConjureFieldDefinition('raw', scout_compute_api_Reference),
             'channel': ConjureFieldDefinition('channel', scout_compute_api_ChannelSeries),
-            'time_range_filter': ConjureFieldDefinition('timeRangeFilter', scout_compute_api_LogTimeRangeFilterSeries),
             'union': ConjureFieldDefinition('union', scout_compute_api_LogUnionSeries),
-            'value_filter': ConjureFieldDefinition('valueFilter', scout_compute_api_LogValueFilterSeries)
+            'filter': ConjureFieldDefinition('filter', scout_compute_api_LogFilterSeries),
+            'time_shift': ConjureFieldDefinition('timeShift', scout_compute_api_LogTimeShiftSeries)
         }
 
     def __init__(
             self,
             raw: Optional["scout_compute_api_Reference"] = None,
             channel: Optional["scout_compute_api_ChannelSeries"] = None,
-            time_range_filter: Optional["scout_compute_api_LogTimeRangeFilterSeries"] = None,
             union: Optional["scout_compute_api_LogUnionSeries"] = None,
-            value_filter: Optional["scout_compute_api_LogValueFilterSeries"] = None,
+            filter: Optional["scout_compute_api_LogFilterSeries"] = None,
+            time_shift: Optional["scout_compute_api_LogTimeShiftSeries"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (raw is not None) + (channel is not None) + (time_range_filter is not None) + (union is not None) + (value_filter is not None) != 1:
+            if (raw is not None) + (channel is not None) + (union is not None) + (filter is not None) + (time_shift is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if raw is not None:
@@ -32300,15 +32362,15 @@ class scout_compute_api_LogSeries(ConjureUnionType):
             if channel is not None:
                 self._channel = channel
                 self._type = 'channel'
-            if time_range_filter is not None:
-                self._time_range_filter = time_range_filter
-                self._type = 'timeRangeFilter'
             if union is not None:
                 self._union = union
                 self._type = 'union'
-            if value_filter is not None:
-                self._value_filter = value_filter
-                self._type = 'valueFilter'
+            if filter is not None:
+                self._filter = filter
+                self._type = 'filter'
+            if time_shift is not None:
+                self._time_shift = time_shift
+                self._type = 'timeShift'
 
         elif type_of_union == 'raw':
             if raw is None:
@@ -32320,21 +32382,21 @@ class scout_compute_api_LogSeries(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._channel = channel
             self._type = 'channel'
-        elif type_of_union == 'timeRangeFilter':
-            if time_range_filter is None:
-                raise ValueError('a union value must not be None')
-            self._time_range_filter = time_range_filter
-            self._type = 'timeRangeFilter'
         elif type_of_union == 'union':
             if union is None:
                 raise ValueError('a union value must not be None')
             self._union = union
             self._type = 'union'
-        elif type_of_union == 'valueFilter':
-            if value_filter is None:
+        elif type_of_union == 'filter':
+            if filter is None:
+                raise ValueError('a union value must not be None')
+            self._filter = filter
+            self._type = 'filter'
+        elif type_of_union == 'timeShift':
+            if time_shift is None:
                 raise ValueError('a union value must not be None')
-            self._value_filter = value_filter
-            self._type = 'valueFilter'
+            self._time_shift = time_shift
+            self._type = 'timeShift'
 
     @builtins.property
     def raw(self) -> Optional["scout_compute_api_Reference"]:
@@ -32344,17 +32406,17 @@ class scout_compute_api_LogSeries(ConjureUnionType):
     def channel(self) -> Optional["scout_compute_api_ChannelSeries"]:
         return self._channel
 
-    @builtins.property
-    def time_range_filter(self) -> Optional["scout_compute_api_LogTimeRangeFilterSeries"]:
-        return self._time_range_filter
-
     @builtins.property
     def union(self) -> Optional["scout_compute_api_LogUnionSeries"]:
         return self._union
 
     @builtins.property
-    def value_filter(self) -> Optional["scout_compute_api_LogValueFilterSeries"]:
-        return self._value_filter
+    def filter(self) -> Optional["scout_compute_api_LogFilterSeries"]:
+        return self._filter
+
+    @builtins.property
+    def time_shift(self) -> Optional["scout_compute_api_LogTimeShiftSeries"]:
+        return self._time_shift
 
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, scout_compute_api_LogSeriesVisitor):
@@ -32363,12 +32425,12 @@ class scout_compute_api_LogSeries(ConjureUnionType):
             return visitor._raw(self.raw)
         if self._type == 'channel' and self.channel is not None:
             return visitor._channel(self.channel)
-        if self._type == 'timeRangeFilter' and self.time_range_filter is not None:
-            return visitor._time_range_filter(self.time_range_filter)
         if self._type == 'union' and self.union is not None:
             return visitor._union(self.union)
-        if self._type == 'valueFilter' and self.value_filter is not None:
-            return visitor._value_filter(self.value_filter)
+        if self._type == 'filter' and self.filter is not None:
+            return visitor._filter(self.filter)
+        if self._type == 'timeShift' and self.time_shift is not None:
+            return visitor._time_shift(self.time_shift)
 
 
 scout_compute_api_LogSeries.__name__ = "LogSeries"
@@ -32387,15 +32449,15 @@ class scout_compute_api_LogSeriesVisitor:
         pass
 
     @abstractmethod
-    def _time_range_filter(self, time_range_filter: "scout_compute_api_LogTimeRangeFilterSeries") -> Any:
+    def _union(self, union: "scout_compute_api_LogUnionSeries") -> Any:
         pass
 
     @abstractmethod
-    def _union(self, union: "scout_compute_api_LogUnionSeries") -> Any:
+    def _filter(self, filter: "scout_compute_api_LogFilterSeries") -> Any:
         pass
 
     @abstractmethod
-    def _value_filter(self, value_filter: "scout_compute_api_LogValueFilterSeries") -> Any:
+    def _time_shift(self, time_shift: "scout_compute_api_LogTimeShiftSeries") -> Any:
         pass
 
 
@@ -32404,48 +32466,33 @@ scout_compute_api_LogSeriesVisitor.__qualname__ = "LogSeriesVisitor"
 scout_compute_api_LogSeriesVisitor.__module__ = "nominal_api.scout_compute_api"
 
 
-class scout_compute_api_LogTimeRangeFilterSeries(ConjureBeanType):
-    """
-    Filters the series to points within the specified time range.
-    """
+class scout_compute_api_LogTimeShiftSeries(ConjureBeanType):
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'input': ConjureFieldDefinition('input', scout_compute_api_LogSeries),
-            'start_time': ConjureFieldDefinition('startTime', OptionalTypeWrapper[scout_compute_api_TimestampConstant]),
-            'end_time': ConjureFieldDefinition('endTime', OptionalTypeWrapper[scout_compute_api_TimestampConstant])
+            'duration': ConjureFieldDefinition('duration', scout_compute_api_DurationConstant)
         }
 
-    __slots__: List[str] = ['_input', '_start_time', '_end_time']
+    __slots__: List[str] = ['_input', '_duration']
 
-    def __init__(self, input: "scout_compute_api_LogSeries", end_time: Optional["scout_compute_api_TimestampConstant"] = None, start_time: Optional["scout_compute_api_TimestampConstant"] = None) -> None:
+    def __init__(self, duration: "scout_compute_api_DurationConstant", input: "scout_compute_api_LogSeries") -> None:
         self._input = input
-        self._start_time = start_time
-        self._end_time = end_time
+        self._duration = duration
 
     @builtins.property
     def input(self) -> "scout_compute_api_LogSeries":
         return self._input
 
     @builtins.property
-    def start_time(self) -> Optional["scout_compute_api_TimestampConstant"]:
-        """
-        Represents the start time (inclusive) of the time range.
-        """
-        return self._start_time
-
-    @builtins.property
-    def end_time(self) -> Optional["scout_compute_api_TimestampConstant"]:
-        """
-        Represents the end time (inclusive) of the time range.
-        """
-        return self._end_time
+    def duration(self) -> "scout_compute_api_DurationConstant":
+        return self._duration
 
 
-scout_compute_api_LogTimeRangeFilterSeries.__name__ = "LogTimeRangeFilterSeries"
-scout_compute_api_LogTimeRangeFilterSeries.__qualname__ = "LogTimeRangeFilterSeries"
-scout_compute_api_LogTimeRangeFilterSeries.__module__ = "nominal_api.scout_compute_api"
+scout_compute_api_LogTimeShiftSeries.__name__ = "LogTimeShiftSeries"
+scout_compute_api_LogTimeShiftSeries.__qualname__ = "LogTimeShiftSeries"
+scout_compute_api_LogTimeShiftSeries.__module__ = "nominal_api.scout_compute_api"
 
 
 class scout_compute_api_LogUnionOperation(ConjureEnumType):
@@ -32529,112 +32576,6 @@ scout_compute_api_LogValue.__qualname__ = "LogValue"
 scout_compute_api_LogValue.__module__ = "nominal_api.scout_compute_api"
 
 
-class scout_compute_api_LogValueFilterOperator(ConjureUnionType):
-    _arg_filter: Optional["scout_compute_api_LogArgFilterOperator"] = None
-    _regex_filter: Optional["scout_compute_api_LogRegexFilterOperator"] = None
-
-    @builtins.classmethod
-    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'arg_filter': ConjureFieldDefinition('argFilter', scout_compute_api_LogArgFilterOperator),
-            'regex_filter': ConjureFieldDefinition('regexFilter', scout_compute_api_LogRegexFilterOperator)
-        }
-
-    def __init__(
-            self,
-            arg_filter: Optional["scout_compute_api_LogArgFilterOperator"] = None,
-            regex_filter: Optional["scout_compute_api_LogRegexFilterOperator"] = None,
-            type_of_union: Optional[str] = None
-            ) -> None:
-        if type_of_union is None:
-            if (arg_filter is not None) + (regex_filter is not None) != 1:
-                raise ValueError('a union must contain a single member')
-
-            if arg_filter is not None:
-                self._arg_filter = arg_filter
-                self._type = 'argFilter'
-            if regex_filter is not None:
-                self._regex_filter = regex_filter
-                self._type = 'regexFilter'
-
-        elif type_of_union == 'argFilter':
-            if arg_filter is None:
-                raise ValueError('a union value must not be None')
-            self._arg_filter = arg_filter
-            self._type = 'argFilter'
-        elif type_of_union == 'regexFilter':
-            if regex_filter is None:
-                raise ValueError('a union value must not be None')
-            self._regex_filter = regex_filter
-            self._type = 'regexFilter'
-
-    @builtins.property
-    def arg_filter(self) -> Optional["scout_compute_api_LogArgFilterOperator"]:
-        return self._arg_filter
-
-    @builtins.property
-    def regex_filter(self) -> Optional["scout_compute_api_LogRegexFilterOperator"]:
-        return self._regex_filter
-
-    def accept(self, visitor) -> Any:
-        if not isinstance(visitor, scout_compute_api_LogValueFilterOperatorVisitor):
-            raise ValueError('{} is not an instance of scout_compute_api_LogValueFilterOperatorVisitor'.format(visitor.__class__.__name__))
-        if self._type == 'argFilter' and self.arg_filter is not None:
-            return visitor._arg_filter(self.arg_filter)
-        if self._type == 'regexFilter' and self.regex_filter is not None:
-            return visitor._regex_filter(self.regex_filter)
-
-
-scout_compute_api_LogValueFilterOperator.__name__ = "LogValueFilterOperator"
-scout_compute_api_LogValueFilterOperator.__qualname__ = "LogValueFilterOperator"
-scout_compute_api_LogValueFilterOperator.__module__ = "nominal_api.scout_compute_api"
-
-
-class scout_compute_api_LogValueFilterOperatorVisitor:
-
-    @abstractmethod
-    def _arg_filter(self, arg_filter: "scout_compute_api_LogArgFilterOperator") -> Any:
-        pass
-
-    @abstractmethod
-    def _regex_filter(self, regex_filter: "scout_compute_api_LogRegexFilterOperator") -> Any:
-        pass
-
-
-scout_compute_api_LogValueFilterOperatorVisitor.__name__ = "LogValueFilterOperatorVisitor"
-scout_compute_api_LogValueFilterOperatorVisitor.__qualname__ = "LogValueFilterOperatorVisitor"
-scout_compute_api_LogValueFilterOperatorVisitor.__module__ = "nominal_api.scout_compute_api"
-
-
-class scout_compute_api_LogValueFilterSeries(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'input': ConjureFieldDefinition('input', scout_compute_api_LogSeries),
-            'operator': ConjureFieldDefinition('operator', scout_compute_api_LogValueFilterOperator)
-        }
-
-    __slots__: List[str] = ['_input', '_operator']
-
-    def __init__(self, input: "scout_compute_api_LogSeries", operator: "scout_compute_api_LogValueFilterOperator") -> None:
-        self._input = input
-        self._operator = operator
-
-    @builtins.property
-    def input(self) -> "scout_compute_api_LogSeries":
-        return self._input
-
-    @builtins.property
-    def operator(self) -> "scout_compute_api_LogValueFilterOperator":
-        return self._operator
-
-
-scout_compute_api_LogValueFilterSeries.__name__ = "LogValueFilterSeries"
-scout_compute_api_LogValueFilterSeries.__qualname__ = "LogValueFilterSeries"
-scout_compute_api_LogValueFilterSeries.__module__ = "nominal_api.scout_compute_api"
-
-
 class scout_compute_api_LowPassConfiguration(ConjureBeanType):
 
     @builtins.classmethod
@@ -35096,95 +35037,101 @@ scout_compute_api_RangeAggregationOperationVisitor.__module__ = "nominal_api.sco
 
 
 class scout_compute_api_RangeSeries(ConjureUnionType):
+    _approximate_threshold: Optional["scout_compute_api_ApproximateThresholdRanges"] = None
     _enum_filter: Optional["scout_compute_api_EnumFilterRanges"] = None
+    _enum_series_equality_ranges_node: Optional["scout_compute_api_EnumSeriesEqualityRanges"] = None
     _function: Optional["scout_compute_api_RangesFunction"] = None
     _intersect_range: Optional["scout_compute_api_IntersectRanges"] = None
+    _min_max_threshold: Optional["scout_compute_api_MinMaxThresholdRanges"] = None
     _not_: Optional["scout_compute_api_NotRanges"] = None
     _on_change: Optional["scout_compute_api_OnChangeRanges"] = None
-    _approximate_threshold: Optional["scout_compute_api_ApproximateThresholdRanges"] = None
-    _min_max_threshold: Optional["scout_compute_api_MinMaxThresholdRanges"] = None
     _peak: Optional["scout_compute_api_PeakRanges"] = None
+    _range_numeric_aggregation: Optional["scout_compute_api_RangesNumericAggregation"] = None
     _raw: Optional["scout_compute_api_Reference"] = None
     _series_crossover_ranges_node: Optional["scout_compute_api_SeriesCrossoverRanges"] = None
     _series_equality_ranges_node: Optional["scout_compute_api_SeriesEqualityRanges"] = None
-    _enum_series_equality_ranges_node: Optional["scout_compute_api_EnumSeriesEqualityRanges"] = None
+    _stability_detection: Optional["scout_compute_api_StabilityDetectionRanges"] = None
     _stale_range: Optional["scout_compute_api_StaleRanges"] = None
     _threshold: Optional["scout_compute_api_ThresholdingRanges"] = None
     _union_range: Optional["scout_compute_api_UnionRanges"] = None
-    _range_numeric_aggregation: Optional["scout_compute_api_RangesNumericAggregation"] = None
-    _stability_detection: Optional["scout_compute_api_StabilityDetectionRanges"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
+            'approximate_threshold': ConjureFieldDefinition('approximateThreshold', scout_compute_api_ApproximateThresholdRanges),
             'enum_filter': ConjureFieldDefinition('enumFilter', scout_compute_api_EnumFilterRanges),
+            'enum_series_equality_ranges_node': ConjureFieldDefinition('enumSeriesEqualityRangesNode', scout_compute_api_EnumSeriesEqualityRanges),
             'function': ConjureFieldDefinition('function', scout_compute_api_RangesFunction),
             'intersect_range': ConjureFieldDefinition('intersectRange', scout_compute_api_IntersectRanges),
+            'min_max_threshold': ConjureFieldDefinition('minMaxThreshold', scout_compute_api_MinMaxThresholdRanges),
             'not_': ConjureFieldDefinition('not', scout_compute_api_NotRanges),
             'on_change': ConjureFieldDefinition('onChange', scout_compute_api_OnChangeRanges),
-            'approximate_threshold': ConjureFieldDefinition('approximateThreshold', scout_compute_api_ApproximateThresholdRanges),
-            'min_max_threshold': ConjureFieldDefinition('minMaxThreshold', scout_compute_api_MinMaxThresholdRanges),
             'peak': ConjureFieldDefinition('peak', scout_compute_api_PeakRanges),
+            'range_numeric_aggregation': ConjureFieldDefinition('rangeNumericAggregation', scout_compute_api_RangesNumericAggregation),
             'raw': ConjureFieldDefinition('raw', scout_compute_api_Reference),
             'series_crossover_ranges_node': ConjureFieldDefinition('seriesCrossoverRangesNode', scout_compute_api_SeriesCrossoverRanges),
             'series_equality_ranges_node': ConjureFieldDefinition('seriesEqualityRangesNode', scout_compute_api_SeriesEqualityRanges),
-            'enum_series_equality_ranges_node': ConjureFieldDefinition('enumSeriesEqualityRangesNode', scout_compute_api_EnumSeriesEqualityRanges),
+            '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),
-            'range_numeric_aggregation': ConjureFieldDefinition('rangeNumericAggregation', scout_compute_api_RangesNumericAggregation),
-            'stability_detection': ConjureFieldDefinition('stabilityDetection', scout_compute_api_StabilityDetectionRanges)
+            'union_range': ConjureFieldDefinition('unionRange', scout_compute_api_UnionRanges)
         }
 
     def __init__(
             self,
+            approximate_threshold: Optional["scout_compute_api_ApproximateThresholdRanges"] = None,
             enum_filter: Optional["scout_compute_api_EnumFilterRanges"] = None,
+            enum_series_equality_ranges_node: Optional["scout_compute_api_EnumSeriesEqualityRanges"] = None,
             function: Optional["scout_compute_api_RangesFunction"] = None,
             intersect_range: Optional["scout_compute_api_IntersectRanges"] = None,
+            min_max_threshold: Optional["scout_compute_api_MinMaxThresholdRanges"] = None,
             not_: Optional["scout_compute_api_NotRanges"] = None,
             on_change: Optional["scout_compute_api_OnChangeRanges"] = None,
-            approximate_threshold: Optional["scout_compute_api_ApproximateThresholdRanges"] = None,
-            min_max_threshold: Optional["scout_compute_api_MinMaxThresholdRanges"] = None,
             peak: Optional["scout_compute_api_PeakRanges"] = None,
+            range_numeric_aggregation: Optional["scout_compute_api_RangesNumericAggregation"] = None,
             raw: Optional["scout_compute_api_Reference"] = None,
             series_crossover_ranges_node: Optional["scout_compute_api_SeriesCrossoverRanges"] = None,
             series_equality_ranges_node: Optional["scout_compute_api_SeriesEqualityRanges"] = None,
-            enum_series_equality_ranges_node: Optional["scout_compute_api_EnumSeriesEqualityRanges"] = None,
+            stability_detection: Optional["scout_compute_api_StabilityDetectionRanges"] = None,
             stale_range: Optional["scout_compute_api_StaleRanges"] = None,
             threshold: Optional["scout_compute_api_ThresholdingRanges"] = None,
             union_range: Optional["scout_compute_api_UnionRanges"] = None,
-            range_numeric_aggregation: Optional["scout_compute_api_RangesNumericAggregation"] = None,
-            stability_detection: Optional["scout_compute_api_StabilityDetectionRanges"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (enum_filter is not None) + (function is not None) + (intersect_range is not None) + (not_ is not None) + (on_change is not None) + (approximate_threshold is not None) + (min_max_threshold is not None) + (peak is not None) + (raw is not None) + (series_crossover_ranges_node is not None) + (series_equality_ranges_node is not None) + (enum_series_equality_ranges_node is not None) + (stale_range is not None) + (threshold is not None) + (union_range is not None) + (range_numeric_aggregation is not None) + (stability_detection is not None) != 1:
+            if (approximate_threshold is not None) + (enum_filter is not None) + (enum_series_equality_ranges_node is not None) + (function is not None) + (intersect_range 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) + (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:
                 raise ValueError('a union must contain a single member')
 
+            if approximate_threshold is not None:
+                self._approximate_threshold = approximate_threshold
+                self._type = 'approximateThreshold'
             if enum_filter is not None:
                 self._enum_filter = enum_filter
                 self._type = 'enumFilter'
+            if enum_series_equality_ranges_node is not None:
+                self._enum_series_equality_ranges_node = enum_series_equality_ranges_node
+                self._type = 'enumSeriesEqualityRangesNode'
             if function is not None:
                 self._function = function
                 self._type = 'function'
             if intersect_range is not None:
                 self._intersect_range = intersect_range
                 self._type = 'intersectRange'
+            if min_max_threshold is not None:
+                self._min_max_threshold = min_max_threshold
+                self._type = 'minMaxThreshold'
             if not_ is not None:
                 self._not_ = not_
                 self._type = 'not'
             if on_change is not None:
                 self._on_change = on_change
                 self._type = 'onChange'
-            if approximate_threshold is not None:
-                self._approximate_threshold = approximate_threshold
-                self._type = 'approximateThreshold'
-            if min_max_threshold is not None:
-                self._min_max_threshold = min_max_threshold
-                self._type = 'minMaxThreshold'
             if peak is not None:
                 self._peak = peak
                 self._type = 'peak'
+            if range_numeric_aggregation is not None:
+                self._range_numeric_aggregation = range_numeric_aggregation
+                self._type = 'rangeNumericAggregation'
             if raw is not None:
                 self._raw = raw
                 self._type = 'raw'
@@ -35194,9 +35141,9 @@ class scout_compute_api_RangeSeries(ConjureUnionType):
             if series_equality_ranges_node is not None:
                 self._series_equality_ranges_node = series_equality_ranges_node
                 self._type = 'seriesEqualityRangesNode'
-            if enum_series_equality_ranges_node is not None:
-                self._enum_series_equality_ranges_node = enum_series_equality_ranges_node
-                self._type = 'enumSeriesEqualityRangesNode'
+            if stability_detection is not None:
+                self._stability_detection = stability_detection
+                self._type = 'stabilityDetection'
             if stale_range is not None:
                 self._stale_range = stale_range
                 self._type = 'staleRange'
@@ -35206,18 +35153,22 @@ class scout_compute_api_RangeSeries(ConjureUnionType):
             if union_range is not None:
                 self._union_range = union_range
                 self._type = 'unionRange'
-            if range_numeric_aggregation is not None:
-                self._range_numeric_aggregation = range_numeric_aggregation
-                self._type = 'rangeNumericAggregation'
-            if stability_detection is not None:
-                self._stability_detection = stability_detection
-                self._type = 'stabilityDetection'
 
+        elif type_of_union == 'approximateThreshold':
+            if approximate_threshold is None:
+                raise ValueError('a union value must not be None')
+            self._approximate_threshold = approximate_threshold
+            self._type = 'approximateThreshold'
         elif type_of_union == 'enumFilter':
             if enum_filter is None:
                 raise ValueError('a union value must not be None')
             self._enum_filter = enum_filter
             self._type = 'enumFilter'
+        elif type_of_union == 'enumSeriesEqualityRangesNode':
+            if enum_series_equality_ranges_node is None:
+                raise ValueError('a union value must not be None')
+            self._enum_series_equality_ranges_node = enum_series_equality_ranges_node
+            self._type = 'enumSeriesEqualityRangesNode'
         elif type_of_union == 'function':
             if function is None:
                 raise ValueError('a union value must not be None')
@@ -35228,6 +35179,11 @@ class scout_compute_api_RangeSeries(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._intersect_range = intersect_range
             self._type = 'intersectRange'
+        elif type_of_union == 'minMaxThreshold':
+            if min_max_threshold is None:
+                raise ValueError('a union value must not be None')
+            self._min_max_threshold = min_max_threshold
+            self._type = 'minMaxThreshold'
         elif type_of_union == 'not':
             if not_ is None:
                 raise ValueError('a union value must not be None')
@@ -35238,21 +35194,16 @@ class scout_compute_api_RangeSeries(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._on_change = on_change
             self._type = 'onChange'
-        elif type_of_union == 'approximateThreshold':
-            if approximate_threshold is None:
-                raise ValueError('a union value must not be None')
-            self._approximate_threshold = approximate_threshold
-            self._type = 'approximateThreshold'
-        elif type_of_union == 'minMaxThreshold':
-            if min_max_threshold is None:
-                raise ValueError('a union value must not be None')
-            self._min_max_threshold = min_max_threshold
-            self._type = 'minMaxThreshold'
         elif type_of_union == 'peak':
             if peak is None:
                 raise ValueError('a union value must not be None')
             self._peak = peak
             self._type = 'peak'
+        elif type_of_union == 'rangeNumericAggregation':
+            if range_numeric_aggregation is None:
+                raise ValueError('a union value must not be None')
+            self._range_numeric_aggregation = range_numeric_aggregation
+            self._type = 'rangeNumericAggregation'
         elif type_of_union == 'raw':
             if raw is None:
                 raise ValueError('a union value must not be None')
@@ -35268,11 +35219,11 @@ class scout_compute_api_RangeSeries(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._series_equality_ranges_node = series_equality_ranges_node
             self._type = 'seriesEqualityRangesNode'
-        elif type_of_union == 'enumSeriesEqualityRangesNode':
-            if enum_series_equality_ranges_node is None:
+        elif type_of_union == 'stabilityDetection':
+            if stability_detection is None:
                 raise ValueError('a union value must not be None')
-            self._enum_series_equality_ranges_node = enum_series_equality_ranges_node
-            self._type = 'enumSeriesEqualityRangesNode'
+            self._stability_detection = stability_detection
+            self._type = 'stabilityDetection'
         elif type_of_union == 'staleRange':
             if stale_range is None:
                 raise ValueError('a union value must not be None')
@@ -35288,21 +35239,19 @@ 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 == 'rangeNumericAggregation':
-            if range_numeric_aggregation is None:
-                raise ValueError('a union value must not be None')
-            self._range_numeric_aggregation = range_numeric_aggregation
-            self._type = 'rangeNumericAggregation'
-        elif type_of_union == 'stabilityDetection':
-            if stability_detection is None:
-                raise ValueError('a union value must not be None')
-            self._stability_detection = stability_detection
-            self._type = 'stabilityDetection'
+
+    @builtins.property
+    def approximate_threshold(self) -> Optional["scout_compute_api_ApproximateThresholdRanges"]:
+        return self._approximate_threshold
 
     @builtins.property
     def enum_filter(self) -> Optional["scout_compute_api_EnumFilterRanges"]:
         return self._enum_filter
 
+    @builtins.property
+    def enum_series_equality_ranges_node(self) -> Optional["scout_compute_api_EnumSeriesEqualityRanges"]:
+        return self._enum_series_equality_ranges_node
+
     @builtins.property
     def function(self) -> Optional["scout_compute_api_RangesFunction"]:
         return self._function
@@ -35311,6 +35260,13 @@ class scout_compute_api_RangeSeries(ConjureUnionType):
     def intersect_range(self) -> Optional["scout_compute_api_IntersectRanges"]:
         return self._intersect_range
 
+    @builtins.property
+    def min_max_threshold(self) -> Optional["scout_compute_api_MinMaxThresholdRanges"]:
+        """
+        Computes ranges where the input time series matches a filter defined by lower and upper bounds, and an operator.
+        """
+        return self._min_max_threshold
+
     @builtins.property
     def not_(self) -> Optional["scout_compute_api_NotRanges"]:
         return self._not_
@@ -35319,21 +35275,14 @@ class scout_compute_api_RangeSeries(ConjureUnionType):
     def on_change(self) -> Optional["scout_compute_api_OnChangeRanges"]:
         return self._on_change
 
-    @builtins.property
-    def approximate_threshold(self) -> Optional["scout_compute_api_ApproximateThresholdRanges"]:
-        return self._approximate_threshold
-
-    @builtins.property
-    def min_max_threshold(self) -> Optional["scout_compute_api_MinMaxThresholdRanges"]:
-        """
-        Computes ranges where the input time series matches a filter defined by lower and upper bounds, and an operator.
-        """
-        return self._min_max_threshold
-
     @builtins.property
     def peak(self) -> Optional["scout_compute_api_PeakRanges"]:
         return self._peak
 
+    @builtins.property
+    def range_numeric_aggregation(self) -> Optional["scout_compute_api_RangesNumericAggregation"]:
+        return self._range_numeric_aggregation
+
     @builtins.property
     def raw(self) -> Optional["scout_compute_api_Reference"]:
         return self._raw
@@ -35347,8 +35296,8 @@ class scout_compute_api_RangeSeries(ConjureUnionType):
         return self._series_equality_ranges_node
 
     @builtins.property
-    def enum_series_equality_ranges_node(self) -> Optional["scout_compute_api_EnumSeriesEqualityRanges"]:
-        return self._enum_series_equality_ranges_node
+    def stability_detection(self) -> Optional["scout_compute_api_StabilityDetectionRanges"]:
+        return self._stability_detection
 
     @builtins.property
     def stale_range(self) -> Optional["scout_compute_api_StaleRanges"]:
@@ -35365,51 +35314,43 @@ class scout_compute_api_RangeSeries(ConjureUnionType):
     def union_range(self) -> Optional["scout_compute_api_UnionRanges"]:
         return self._union_range
 
-    @builtins.property
-    def range_numeric_aggregation(self) -> Optional["scout_compute_api_RangesNumericAggregation"]:
-        return self._range_numeric_aggregation
-
-    @builtins.property
-    def stability_detection(self) -> Optional["scout_compute_api_StabilityDetectionRanges"]:
-        return self._stability_detection
-
     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__))
+        if self._type == 'approximateThreshold' and self.approximate_threshold is not None:
+            return visitor._approximate_threshold(self.approximate_threshold)
         if self._type == 'enumFilter' and self.enum_filter is not None:
             return visitor._enum_filter(self.enum_filter)
+        if self._type == 'enumSeriesEqualityRangesNode' and self.enum_series_equality_ranges_node is not None:
+            return visitor._enum_series_equality_ranges_node(self.enum_series_equality_ranges_node)
         if self._type == 'function' and self.function is not None:
             return visitor._function(self.function)
         if self._type == 'intersectRange' and self.intersect_range is not None:
             return visitor._intersect_range(self.intersect_range)
+        if self._type == 'minMaxThreshold' and self.min_max_threshold is not None:
+            return visitor._min_max_threshold(self.min_max_threshold)
         if self._type == 'not' and self.not_ is not None:
             return visitor._not(self.not_)
         if self._type == 'onChange' and self.on_change is not None:
             return visitor._on_change(self.on_change)
-        if self._type == 'approximateThreshold' and self.approximate_threshold is not None:
-            return visitor._approximate_threshold(self.approximate_threshold)
-        if self._type == 'minMaxThreshold' and self.min_max_threshold is not None:
-            return visitor._min_max_threshold(self.min_max_threshold)
         if self._type == 'peak' and self.peak is not None:
             return visitor._peak(self.peak)
+        if self._type == 'rangeNumericAggregation' and self.range_numeric_aggregation is not None:
+            return visitor._range_numeric_aggregation(self.range_numeric_aggregation)
         if self._type == 'raw' and self.raw is not None:
             return visitor._raw(self.raw)
         if self._type == 'seriesCrossoverRangesNode' and self.series_crossover_ranges_node is not None:
             return visitor._series_crossover_ranges_node(self.series_crossover_ranges_node)
         if self._type == 'seriesEqualityRangesNode' and self.series_equality_ranges_node is not None:
             return visitor._series_equality_ranges_node(self.series_equality_ranges_node)
-        if self._type == 'enumSeriesEqualityRangesNode' and self.enum_series_equality_ranges_node is not None:
-            return visitor._enum_series_equality_ranges_node(self.enum_series_equality_ranges_node)
+        if self._type == 'stabilityDetection' and self.stability_detection is not None:
+            return visitor._stability_detection(self.stability_detection)
         if self._type == 'staleRange' and self.stale_range is not None:
             return visitor._stale_range(self.stale_range)
         if self._type == 'threshold' and self.threshold is not None:
             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 == 'rangeNumericAggregation' and self.range_numeric_aggregation is not None:
-            return visitor._range_numeric_aggregation(self.range_numeric_aggregation)
-        if self._type == 'stabilityDetection' and self.stability_detection is not None:
-            return visitor._stability_detection(self.stability_detection)
 
 
 scout_compute_api_RangeSeries.__name__ = "RangeSeries"
@@ -35419,10 +35360,18 @@ scout_compute_api_RangeSeries.__module__ = "nominal_api.scout_compute_api"
 
 class scout_compute_api_RangeSeriesVisitor:
 
+    @abstractmethod
+    def _approximate_threshold(self, approximate_threshold: "scout_compute_api_ApproximateThresholdRanges") -> Any:
+        pass
+
     @abstractmethod
     def _enum_filter(self, enum_filter: "scout_compute_api_EnumFilterRanges") -> Any:
         pass
 
+    @abstractmethod
+    def _enum_series_equality_ranges_node(self, enum_series_equality_ranges_node: "scout_compute_api_EnumSeriesEqualityRanges") -> Any:
+        pass
+
     @abstractmethod
     def _function(self, function: "scout_compute_api_RangesFunction") -> Any:
         pass
@@ -35432,23 +35381,23 @@ class scout_compute_api_RangeSeriesVisitor:
         pass
 
     @abstractmethod
-    def _not(self, not_: "scout_compute_api_NotRanges") -> Any:
+    def _min_max_threshold(self, min_max_threshold: "scout_compute_api_MinMaxThresholdRanges") -> Any:
         pass
 
     @abstractmethod
-    def _on_change(self, on_change: "scout_compute_api_OnChangeRanges") -> Any:
+    def _not(self, not_: "scout_compute_api_NotRanges") -> Any:
         pass
 
     @abstractmethod
-    def _approximate_threshold(self, approximate_threshold: "scout_compute_api_ApproximateThresholdRanges") -> Any:
+    def _on_change(self, on_change: "scout_compute_api_OnChangeRanges") -> Any:
         pass
 
     @abstractmethod
-    def _min_max_threshold(self, min_max_threshold: "scout_compute_api_MinMaxThresholdRanges") -> Any:
+    def _peak(self, peak: "scout_compute_api_PeakRanges") -> Any:
         pass
 
     @abstractmethod
-    def _peak(self, peak: "scout_compute_api_PeakRanges") -> Any:
+    def _range_numeric_aggregation(self, range_numeric_aggregation: "scout_compute_api_RangesNumericAggregation") -> Any:
         pass
 
     @abstractmethod
@@ -35464,7 +35413,7 @@ class scout_compute_api_RangeSeriesVisitor:
         pass
 
     @abstractmethod
-    def _enum_series_equality_ranges_node(self, enum_series_equality_ranges_node: "scout_compute_api_EnumSeriesEqualityRanges") -> Any:
+    def _stability_detection(self, stability_detection: "scout_compute_api_StabilityDetectionRanges") -> Any:
         pass
 
     @abstractmethod
@@ -35479,14 +35428,6 @@ class scout_compute_api_RangeSeriesVisitor:
     def _union_range(self, union_range: "scout_compute_api_UnionRanges") -> Any:
         pass
 
-    @abstractmethod
-    def _range_numeric_aggregation(self, range_numeric_aggregation: "scout_compute_api_RangesNumericAggregation") -> Any:
-        pass
-
-    @abstractmethod
-    def _stability_detection(self, stability_detection: "scout_compute_api_StabilityDetectionRanges") -> Any:
-        pass
-
 
 scout_compute_api_RangeSeriesVisitor.__name__ = "RangeSeriesVisitor"
 scout_compute_api_RangeSeriesVisitor.__qualname__ = "RangeSeriesVisitor"
@@ -36081,7 +36022,7 @@ class scout_compute_api_RunChannel(ConjureBeanType):
         """
         Tags to filter the channel by, in addition to tag filters defined for a given Run data scope. Throws on 
 collisions with tag keys already defined for the given Run data scope. Only returns points that match 
-both sets of tag filters.
+both sets of tag filters. For log series, include arg filters here in addition to tag filters.
         """
         return self._additional_tags
 
@@ -42465,6 +42406,250 @@ scout_compute_resolved_api_LatLongGeoNode.__qualname__ = "LatLongGeoNode"
 scout_compute_resolved_api_LatLongGeoNode.__module__ = "nominal_api.scout_compute_resolved_api"
 
 
+class scout_compute_resolved_api_LogFilterRangesNode(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'input': ConjureFieldDefinition('input', scout_compute_resolved_api_LogSeriesNode),
+            'operator': ConjureFieldDefinition('operator', scout_compute_api_LogFilterOperator),
+            'persistence_window_configuration': ConjureFieldDefinition('persistenceWindowConfiguration', OptionalTypeWrapper[scout_compute_resolved_api_PersistenceWindowConfiguration])
+        }
+
+    __slots__: List[str] = ['_input', '_operator', '_persistence_window_configuration']
+
+    def __init__(self, input: "scout_compute_resolved_api_LogSeriesNode", operator: "scout_compute_api_LogFilterOperator", persistence_window_configuration: Optional["scout_compute_resolved_api_PersistenceWindowConfiguration"] = None) -> None:
+        self._input = input
+        self._operator = operator
+        self._persistence_window_configuration = persistence_window_configuration
+
+    @builtins.property
+    def input(self) -> "scout_compute_resolved_api_LogSeriesNode":
+        return self._input
+
+    @builtins.property
+    def operator(self) -> "scout_compute_api_LogFilterOperator":
+        return self._operator
+
+    @builtins.property
+    def persistence_window_configuration(self) -> Optional["scout_compute_resolved_api_PersistenceWindowConfiguration"]:
+        return self._persistence_window_configuration
+
+
+scout_compute_resolved_api_LogFilterRangesNode.__name__ = "LogFilterRangesNode"
+scout_compute_resolved_api_LogFilterRangesNode.__qualname__ = "LogFilterRangesNode"
+scout_compute_resolved_api_LogFilterRangesNode.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
+class scout_compute_resolved_api_LogFilterTransformationSeriesNode(ConjureBeanType):
+    """
+    Outputs the values of the log plot value within the ranges specified by a ranges node
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'input': ConjureFieldDefinition('input', scout_compute_resolved_api_LogSeriesNode),
+            'filter': ConjureFieldDefinition('filter', scout_compute_resolved_api_RangesNode)
+        }
+
+    __slots__: List[str] = ['_input', '_filter']
+
+    def __init__(self, filter: "scout_compute_resolved_api_RangesNode", input: "scout_compute_resolved_api_LogSeriesNode") -> None:
+        self._input = input
+        self._filter = filter
+
+    @builtins.property
+    def input(self) -> "scout_compute_resolved_api_LogSeriesNode":
+        return self._input
+
+    @builtins.property
+    def filter(self) -> "scout_compute_resolved_api_RangesNode":
+        return self._filter
+
+
+scout_compute_resolved_api_LogFilterTransformationSeriesNode.__name__ = "LogFilterTransformationSeriesNode"
+scout_compute_resolved_api_LogFilterTransformationSeriesNode.__qualname__ = "LogFilterTransformationSeriesNode"
+scout_compute_resolved_api_LogFilterTransformationSeriesNode.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
+class scout_compute_resolved_api_LogSeriesNode(ConjureUnionType):
+    _raw: Optional["scout_compute_resolved_api_RawLogSeriesNode"] = None
+    _union: Optional["scout_compute_resolved_api_LogUnionSeriesNode"] = None
+    _filter_transformation: Optional["scout_compute_resolved_api_LogFilterTransformationSeriesNode"] = None
+    _time_shift: Optional["scout_compute_resolved_api_LogTimeShiftSeriesNode"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'raw': ConjureFieldDefinition('raw', scout_compute_resolved_api_RawLogSeriesNode),
+            'union': ConjureFieldDefinition('union', scout_compute_resolved_api_LogUnionSeriesNode),
+            'filter_transformation': ConjureFieldDefinition('filterTransformation', scout_compute_resolved_api_LogFilterTransformationSeriesNode),
+            'time_shift': ConjureFieldDefinition('timeShift', scout_compute_resolved_api_LogTimeShiftSeriesNode)
+        }
+
+    def __init__(
+            self,
+            raw: Optional["scout_compute_resolved_api_RawLogSeriesNode"] = None,
+            union: Optional["scout_compute_resolved_api_LogUnionSeriesNode"] = None,
+            filter_transformation: Optional["scout_compute_resolved_api_LogFilterTransformationSeriesNode"] = None,
+            time_shift: Optional["scout_compute_resolved_api_LogTimeShiftSeriesNode"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (raw is not None) + (union is not None) + (filter_transformation is not None) + (time_shift is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if raw is not None:
+                self._raw = raw
+                self._type = 'raw'
+            if union is not None:
+                self._union = union
+                self._type = 'union'
+            if filter_transformation is not None:
+                self._filter_transformation = filter_transformation
+                self._type = 'filterTransformation'
+            if time_shift is not None:
+                self._time_shift = time_shift
+                self._type = 'timeShift'
+
+        elif type_of_union == 'raw':
+            if raw is None:
+                raise ValueError('a union value must not be None')
+            self._raw = raw
+            self._type = 'raw'
+        elif type_of_union == 'union':
+            if union is None:
+                raise ValueError('a union value must not be None')
+            self._union = union
+            self._type = 'union'
+        elif type_of_union == 'filterTransformation':
+            if filter_transformation is None:
+                raise ValueError('a union value must not be None')
+            self._filter_transformation = filter_transformation
+            self._type = 'filterTransformation'
+        elif type_of_union == 'timeShift':
+            if time_shift is None:
+                raise ValueError('a union value must not be None')
+            self._time_shift = time_shift
+            self._type = 'timeShift'
+
+    @builtins.property
+    def raw(self) -> Optional["scout_compute_resolved_api_RawLogSeriesNode"]:
+        return self._raw
+
+    @builtins.property
+    def union(self) -> Optional["scout_compute_resolved_api_LogUnionSeriesNode"]:
+        return self._union
+
+    @builtins.property
+    def filter_transformation(self) -> Optional["scout_compute_resolved_api_LogFilterTransformationSeriesNode"]:
+        return self._filter_transformation
+
+    @builtins.property
+    def time_shift(self) -> Optional["scout_compute_resolved_api_LogTimeShiftSeriesNode"]:
+        return self._time_shift
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_compute_resolved_api_LogSeriesNodeVisitor):
+            raise ValueError('{} is not an instance of scout_compute_resolved_api_LogSeriesNodeVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'raw' and self.raw is not None:
+            return visitor._raw(self.raw)
+        if self._type == 'union' and self.union is not None:
+            return visitor._union(self.union)
+        if self._type == 'filterTransformation' and self.filter_transformation is not None:
+            return visitor._filter_transformation(self.filter_transformation)
+        if self._type == 'timeShift' and self.time_shift is not None:
+            return visitor._time_shift(self.time_shift)
+
+
+scout_compute_resolved_api_LogSeriesNode.__name__ = "LogSeriesNode"
+scout_compute_resolved_api_LogSeriesNode.__qualname__ = "LogSeriesNode"
+scout_compute_resolved_api_LogSeriesNode.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
+class scout_compute_resolved_api_LogSeriesNodeVisitor:
+
+    @abstractmethod
+    def _raw(self, raw: "scout_compute_resolved_api_RawLogSeriesNode") -> Any:
+        pass
+
+    @abstractmethod
+    def _union(self, union: "scout_compute_resolved_api_LogUnionSeriesNode") -> Any:
+        pass
+
+    @abstractmethod
+    def _filter_transformation(self, filter_transformation: "scout_compute_resolved_api_LogFilterTransformationSeriesNode") -> Any:
+        pass
+
+    @abstractmethod
+    def _time_shift(self, time_shift: "scout_compute_resolved_api_LogTimeShiftSeriesNode") -> Any:
+        pass
+
+
+scout_compute_resolved_api_LogSeriesNodeVisitor.__name__ = "LogSeriesNodeVisitor"
+scout_compute_resolved_api_LogSeriesNodeVisitor.__qualname__ = "LogSeriesNodeVisitor"
+scout_compute_resolved_api_LogSeriesNodeVisitor.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
+class scout_compute_resolved_api_LogTimeShiftSeriesNode(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'input': ConjureFieldDefinition('input', scout_compute_resolved_api_LogSeriesNode),
+            'duration': ConjureFieldDefinition('duration', scout_run_api_Duration)
+        }
+
+    __slots__: List[str] = ['_input', '_duration']
+
+    def __init__(self, duration: "scout_run_api_Duration", input: "scout_compute_resolved_api_LogSeriesNode") -> None:
+        self._input = input
+        self._duration = duration
+
+    @builtins.property
+    def input(self) -> "scout_compute_resolved_api_LogSeriesNode":
+        return self._input
+
+    @builtins.property
+    def duration(self) -> "scout_run_api_Duration":
+        return self._duration
+
+
+scout_compute_resolved_api_LogTimeShiftSeriesNode.__name__ = "LogTimeShiftSeriesNode"
+scout_compute_resolved_api_LogTimeShiftSeriesNode.__qualname__ = "LogTimeShiftSeriesNode"
+scout_compute_resolved_api_LogTimeShiftSeriesNode.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
+class scout_compute_resolved_api_LogUnionSeriesNode(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'input': ConjureFieldDefinition('input', List[scout_compute_resolved_api_LogSeriesNode]),
+            'operation': ConjureFieldDefinition('operation', scout_compute_api_LogUnionOperation)
+        }
+
+    __slots__: List[str] = ['_input', '_operation']
+
+    def __init__(self, input: List["scout_compute_resolved_api_LogSeriesNode"], operation: "scout_compute_api_LogUnionOperation") -> None:
+        self._input = input
+        self._operation = operation
+
+    @builtins.property
+    def input(self) -> List["scout_compute_resolved_api_LogSeriesNode"]:
+        return self._input
+
+    @builtins.property
+    def operation(self) -> "scout_compute_api_LogUnionOperation":
+        return self._operation
+
+
+scout_compute_resolved_api_LogUnionSeriesNode.__name__ = "LogUnionSeriesNode"
+scout_compute_resolved_api_LogUnionSeriesNode.__qualname__ = "LogUnionSeriesNode"
+scout_compute_resolved_api_LogUnionSeriesNode.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
 class scout_compute_resolved_api_LowPassConfiguration(ConjureBeanType):
 
     @builtins.classmethod
@@ -43676,109 +43861,115 @@ scout_compute_resolved_api_ProductSeriesNode.__module__ = "nominal_api.scout_com
 
 
 class scout_compute_resolved_api_RangesNode(ConjureUnionType):
-    _enum_filter: Optional["scout_compute_resolved_api_EnumFilterRangesNode"] = None
     _enum_equality: Optional["scout_compute_resolved_api_EnumEqualityRangesNode"] = None
+    _enum_filter: Optional["scout_compute_resolved_api_EnumFilterRangesNode"] = None
     _extrema: Optional["scout_compute_resolved_api_ExtremaRangesNode"] = None
     _intersect_range: Optional["scout_compute_resolved_api_IntersectRangesNode"] = None
-    _not_: Optional["scout_compute_resolved_api_NotRangesNode"] = None
+    _log_filter: Optional["scout_compute_resolved_api_LogFilterRangesNode"] = None
     _min_max_threshold: Optional["scout_compute_resolved_api_MinMaxThresholdRangesNode"] = None
+    _not_: Optional["scout_compute_resolved_api_NotRangesNode"] = None
     _on_change: Optional["scout_compute_resolved_api_OnChangeRangesNode"] = None
-    _threshold: Optional["scout_compute_resolved_api_ThresholdingRangesNode"] = None
+    _range_numeric_aggregation: Optional["scout_compute_resolved_api_RangesNumericAggregationNode"] = None
     _series_crossover_ranges_node: Optional["scout_compute_resolved_api_SeriesCrossoverRangesNode"] = None
     _stale_range: Optional["scout_compute_resolved_api_StaleRangesNode"] = None
-    _union_range: Optional["scout_compute_resolved_api_UnionRangesNode"] = None
-    _range_numeric_aggregation: Optional["scout_compute_resolved_api_RangesNumericAggregationNode"] = None
     _stability_detection: Optional["scout_compute_resolved_api_StabilityDetectionRangesNode"] = None
+    _threshold: Optional["scout_compute_resolved_api_ThresholdingRangesNode"] = None
+    _union_range: Optional["scout_compute_resolved_api_UnionRangesNode"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'enum_filter': ConjureFieldDefinition('enumFilter', scout_compute_resolved_api_EnumFilterRangesNode),
             'enum_equality': ConjureFieldDefinition('enumEquality', scout_compute_resolved_api_EnumEqualityRangesNode),
+            'enum_filter': ConjureFieldDefinition('enumFilter', scout_compute_resolved_api_EnumFilterRangesNode),
             'extrema': ConjureFieldDefinition('extrema', scout_compute_resolved_api_ExtremaRangesNode),
             'intersect_range': ConjureFieldDefinition('intersectRange', scout_compute_resolved_api_IntersectRangesNode),
-            'not_': ConjureFieldDefinition('not', scout_compute_resolved_api_NotRangesNode),
+            'log_filter': ConjureFieldDefinition('logFilter', scout_compute_resolved_api_LogFilterRangesNode),
             'min_max_threshold': ConjureFieldDefinition('minMaxThreshold', scout_compute_resolved_api_MinMaxThresholdRangesNode),
+            'not_': ConjureFieldDefinition('not', scout_compute_resolved_api_NotRangesNode),
             'on_change': ConjureFieldDefinition('onChange', scout_compute_resolved_api_OnChangeRangesNode),
-            'threshold': ConjureFieldDefinition('threshold', scout_compute_resolved_api_ThresholdingRangesNode),
+            'range_numeric_aggregation': ConjureFieldDefinition('rangeNumericAggregation', scout_compute_resolved_api_RangesNumericAggregationNode),
             'series_crossover_ranges_node': ConjureFieldDefinition('seriesCrossoverRangesNode', scout_compute_resolved_api_SeriesCrossoverRangesNode),
             'stale_range': ConjureFieldDefinition('staleRange', scout_compute_resolved_api_StaleRangesNode),
-            'union_range': ConjureFieldDefinition('unionRange', scout_compute_resolved_api_UnionRangesNode),
-            'range_numeric_aggregation': ConjureFieldDefinition('rangeNumericAggregation', scout_compute_resolved_api_RangesNumericAggregationNode),
-            'stability_detection': ConjureFieldDefinition('stabilityDetection', scout_compute_resolved_api_StabilityDetectionRangesNode)
+            '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)
         }
 
     def __init__(
             self,
-            enum_filter: Optional["scout_compute_resolved_api_EnumFilterRangesNode"] = None,
             enum_equality: Optional["scout_compute_resolved_api_EnumEqualityRangesNode"] = None,
+            enum_filter: Optional["scout_compute_resolved_api_EnumFilterRangesNode"] = None,
             extrema: Optional["scout_compute_resolved_api_ExtremaRangesNode"] = None,
             intersect_range: Optional["scout_compute_resolved_api_IntersectRangesNode"] = None,
-            not_: Optional["scout_compute_resolved_api_NotRangesNode"] = None,
+            log_filter: Optional["scout_compute_resolved_api_LogFilterRangesNode"] = None,
             min_max_threshold: Optional["scout_compute_resolved_api_MinMaxThresholdRangesNode"] = None,
+            not_: Optional["scout_compute_resolved_api_NotRangesNode"] = None,
             on_change: Optional["scout_compute_resolved_api_OnChangeRangesNode"] = None,
-            threshold: Optional["scout_compute_resolved_api_ThresholdingRangesNode"] = None,
+            range_numeric_aggregation: Optional["scout_compute_resolved_api_RangesNumericAggregationNode"] = None,
             series_crossover_ranges_node: Optional["scout_compute_resolved_api_SeriesCrossoverRangesNode"] = None,
             stale_range: Optional["scout_compute_resolved_api_StaleRangesNode"] = None,
-            union_range: Optional["scout_compute_resolved_api_UnionRangesNode"] = None,
-            range_numeric_aggregation: Optional["scout_compute_resolved_api_RangesNumericAggregationNode"] = None,
             stability_detection: Optional["scout_compute_resolved_api_StabilityDetectionRangesNode"] = None,
+            threshold: Optional["scout_compute_resolved_api_ThresholdingRangesNode"] = None,
+            union_range: Optional["scout_compute_resolved_api_UnionRangesNode"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (enum_filter is not None) + (enum_equality is not None) + (extrema is not None) + (intersect_range is not None) + (not_ is not None) + (min_max_threshold is not None) + (on_change is not None) + (threshold is not None) + (series_crossover_ranges_node is not None) + (stale_range is not None) + (union_range is not None) + (range_numeric_aggregation is not None) + (stability_detection is not None) != 1:
+            if (enum_equality is not None) + (enum_filter is not None) + (extrema is not None) + (intersect_range is not None) + (log_filter 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) != 1:
                 raise ValueError('a union must contain a single member')
 
-            if enum_filter is not None:
-                self._enum_filter = enum_filter
-                self._type = 'enumFilter'
             if enum_equality is not None:
                 self._enum_equality = enum_equality
                 self._type = 'enumEquality'
+            if enum_filter is not None:
+                self._enum_filter = enum_filter
+                self._type = 'enumFilter'
             if extrema is not None:
                 self._extrema = extrema
                 self._type = 'extrema'
             if intersect_range is not None:
                 self._intersect_range = intersect_range
                 self._type = 'intersectRange'
-            if not_ is not None:
-                self._not_ = not_
-                self._type = 'not'
+            if log_filter is not None:
+                self._log_filter = log_filter
+                self._type = 'logFilter'
             if min_max_threshold is not None:
                 self._min_max_threshold = min_max_threshold
                 self._type = 'minMaxThreshold'
+            if not_ is not None:
+                self._not_ = not_
+                self._type = 'not'
             if on_change is not None:
                 self._on_change = on_change
                 self._type = 'onChange'
-            if threshold is not None:
-                self._threshold = threshold
-                self._type = 'threshold'
+            if range_numeric_aggregation is not None:
+                self._range_numeric_aggregation = range_numeric_aggregation
+                self._type = 'rangeNumericAggregation'
             if series_crossover_ranges_node is not None:
                 self._series_crossover_ranges_node = series_crossover_ranges_node
                 self._type = 'seriesCrossoverRangesNode'
             if stale_range is not None:
                 self._stale_range = stale_range
                 self._type = 'staleRange'
-            if union_range is not None:
-                self._union_range = union_range
-                self._type = 'unionRange'
-            if range_numeric_aggregation is not None:
-                self._range_numeric_aggregation = range_numeric_aggregation
-                self._type = 'rangeNumericAggregation'
             if stability_detection is not None:
                 self._stability_detection = stability_detection
                 self._type = 'stabilityDetection'
+            if threshold is not None:
+                self._threshold = threshold
+                self._type = 'threshold'
+            if union_range is not None:
+                self._union_range = union_range
+                self._type = 'unionRange'
 
-        elif type_of_union == 'enumFilter':
-            if enum_filter is None:
-                raise ValueError('a union value must not be None')
-            self._enum_filter = enum_filter
-            self._type = 'enumFilter'
         elif type_of_union == 'enumEquality':
             if enum_equality is None:
                 raise ValueError('a union value must not be None')
             self._enum_equality = enum_equality
             self._type = 'enumEquality'
+        elif type_of_union == 'enumFilter':
+            if enum_filter is None:
+                raise ValueError('a union value must not be None')
+            self._enum_filter = enum_filter
+            self._type = 'enumFilter'
         elif type_of_union == 'extrema':
             if extrema is None:
                 raise ValueError('a union value must not be None')
@@ -43789,26 +43980,31 @@ class scout_compute_resolved_api_RangesNode(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._intersect_range = intersect_range
             self._type = 'intersectRange'
-        elif type_of_union == 'not':
-            if not_ is None:
+        elif type_of_union == 'logFilter':
+            if log_filter is None:
                 raise ValueError('a union value must not be None')
-            self._not_ = not_
-            self._type = 'not'
+            self._log_filter = log_filter
+            self._type = 'logFilter'
         elif type_of_union == 'minMaxThreshold':
             if min_max_threshold is None:
                 raise ValueError('a union value must not be None')
             self._min_max_threshold = min_max_threshold
             self._type = 'minMaxThreshold'
+        elif type_of_union == 'not':
+            if not_ is None:
+                raise ValueError('a union value must not be None')
+            self._not_ = not_
+            self._type = 'not'
         elif type_of_union == 'onChange':
             if on_change is None:
                 raise ValueError('a union value must not be None')
             self._on_change = on_change
             self._type = 'onChange'
-        elif type_of_union == 'threshold':
-            if threshold is None:
+        elif type_of_union == 'rangeNumericAggregation':
+            if range_numeric_aggregation is None:
                 raise ValueError('a union value must not be None')
-            self._threshold = threshold
-            self._type = 'threshold'
+            self._range_numeric_aggregation = range_numeric_aggregation
+            self._type = 'rangeNumericAggregation'
         elif type_of_union == 'seriesCrossoverRangesNode':
             if series_crossover_ranges_node is None:
                 raise ValueError('a union value must not be None')
@@ -43819,30 +44015,30 @@ class scout_compute_resolved_api_RangesNode(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._stale_range = stale_range
             self._type = 'staleRange'
-        elif type_of_union == 'unionRange':
-            if union_range is None:
-                raise ValueError('a union value must not be None')
-            self._union_range = union_range
-            self._type = 'unionRange'
-        elif type_of_union == 'rangeNumericAggregation':
-            if range_numeric_aggregation is None:
-                raise ValueError('a union value must not be None')
-            self._range_numeric_aggregation = range_numeric_aggregation
-            self._type = 'rangeNumericAggregation'
         elif type_of_union == 'stabilityDetection':
             if stability_detection is None:
                 raise ValueError('a union value must not be None')
             self._stability_detection = stability_detection
             self._type = 'stabilityDetection'
-
-    @builtins.property
-    def enum_filter(self) -> Optional["scout_compute_resolved_api_EnumFilterRangesNode"]:
-        return self._enum_filter
+        elif type_of_union == 'threshold':
+            if threshold is None:
+                raise ValueError('a union value must not be None')
+            self._threshold = threshold
+            self._type = 'threshold'
+        elif type_of_union == 'unionRange':
+            if union_range is None:
+                raise ValueError('a union value must not be None')
+            self._union_range = union_range
+            self._type = 'unionRange'
 
     @builtins.property
     def enum_equality(self) -> Optional["scout_compute_resolved_api_EnumEqualityRangesNode"]:
         return self._enum_equality
 
+    @builtins.property
+    def enum_filter(self) -> Optional["scout_compute_resolved_api_EnumFilterRangesNode"]:
+        return self._enum_filter
+
     @builtins.property
     def extrema(self) -> Optional["scout_compute_resolved_api_ExtremaRangesNode"]:
         return self._extrema
@@ -43852,20 +44048,24 @@ class scout_compute_resolved_api_RangesNode(ConjureUnionType):
         return self._intersect_range
 
     @builtins.property
-    def not_(self) -> Optional["scout_compute_resolved_api_NotRangesNode"]:
-        return self._not_
+    def log_filter(self) -> Optional["scout_compute_resolved_api_LogFilterRangesNode"]:
+        return self._log_filter
 
     @builtins.property
     def min_max_threshold(self) -> Optional["scout_compute_resolved_api_MinMaxThresholdRangesNode"]:
         return self._min_max_threshold
 
+    @builtins.property
+    def not_(self) -> Optional["scout_compute_resolved_api_NotRangesNode"]:
+        return self._not_
+
     @builtins.property
     def on_change(self) -> Optional["scout_compute_resolved_api_OnChangeRangesNode"]:
         return self._on_change
 
     @builtins.property
-    def threshold(self) -> Optional["scout_compute_resolved_api_ThresholdingRangesNode"]:
-        return self._threshold
+    def range_numeric_aggregation(self) -> Optional["scout_compute_resolved_api_RangesNumericAggregationNode"]:
+        return self._range_numeric_aggregation
 
     @builtins.property
     def series_crossover_ranges_node(self) -> Optional["scout_compute_resolved_api_SeriesCrossoverRangesNode"]:
@@ -43876,46 +44076,48 @@ class scout_compute_resolved_api_RangesNode(ConjureUnionType):
         return self._stale_range
 
     @builtins.property
-    def union_range(self) -> Optional["scout_compute_resolved_api_UnionRangesNode"]:
-        return self._union_range
+    def stability_detection(self) -> Optional["scout_compute_resolved_api_StabilityDetectionRangesNode"]:
+        return self._stability_detection
 
     @builtins.property
-    def range_numeric_aggregation(self) -> Optional["scout_compute_resolved_api_RangesNumericAggregationNode"]:
-        return self._range_numeric_aggregation
+    def threshold(self) -> Optional["scout_compute_resolved_api_ThresholdingRangesNode"]:
+        return self._threshold
 
     @builtins.property
-    def stability_detection(self) -> Optional["scout_compute_resolved_api_StabilityDetectionRangesNode"]:
-        return self._stability_detection
+    def union_range(self) -> Optional["scout_compute_resolved_api_UnionRangesNode"]:
+        return self._union_range
 
     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__))
-        if self._type == 'enumFilter' and self.enum_filter is not None:
-            return visitor._enum_filter(self.enum_filter)
         if self._type == 'enumEquality' and self.enum_equality is not None:
             return visitor._enum_equality(self.enum_equality)
+        if self._type == 'enumFilter' and self.enum_filter is not None:
+            return visitor._enum_filter(self.enum_filter)
         if self._type == 'extrema' and self.extrema is not None:
             return visitor._extrema(self.extrema)
         if self._type == 'intersectRange' and self.intersect_range is not None:
             return visitor._intersect_range(self.intersect_range)
-        if self._type == 'not' and self.not_ is not None:
-            return visitor._not(self.not_)
+        if self._type == 'logFilter' and self.log_filter is not None:
+            return visitor._log_filter(self.log_filter)
         if self._type == 'minMaxThreshold' and self.min_max_threshold is not None:
             return visitor._min_max_threshold(self.min_max_threshold)
+        if self._type == 'not' and self.not_ is not None:
+            return visitor._not(self.not_)
         if self._type == 'onChange' and self.on_change is not None:
             return visitor._on_change(self.on_change)
-        if self._type == 'threshold' and self.threshold is not None:
-            return visitor._threshold(self.threshold)
+        if self._type == 'rangeNumericAggregation' and self.range_numeric_aggregation is not None:
+            return visitor._range_numeric_aggregation(self.range_numeric_aggregation)
         if self._type == 'seriesCrossoverRangesNode' and self.series_crossover_ranges_node is not None:
             return visitor._series_crossover_ranges_node(self.series_crossover_ranges_node)
         if self._type == 'staleRange' and self.stale_range is not None:
             return visitor._stale_range(self.stale_range)
-        if self._type == 'unionRange' and self.union_range is not None:
-            return visitor._union_range(self.union_range)
-        if self._type == 'rangeNumericAggregation' and self.range_numeric_aggregation is not None:
-            return visitor._range_numeric_aggregation(self.range_numeric_aggregation)
         if self._type == 'stabilityDetection' and self.stability_detection is not None:
             return visitor._stability_detection(self.stability_detection)
+        if self._type == 'threshold' and self.threshold is not None:
+            return visitor._threshold(self.threshold)
+        if self._type == 'unionRange' and self.union_range is not None:
+            return visitor._union_range(self.union_range)
 
 
 scout_compute_resolved_api_RangesNode.__name__ = "RangesNode"
@@ -43926,11 +44128,11 @@ scout_compute_resolved_api_RangesNode.__module__ = "nominal_api.scout_compute_re
 class scout_compute_resolved_api_RangesNodeVisitor:
 
     @abstractmethod
-    def _enum_filter(self, enum_filter: "scout_compute_resolved_api_EnumFilterRangesNode") -> Any:
+    def _enum_equality(self, enum_equality: "scout_compute_resolved_api_EnumEqualityRangesNode") -> Any:
         pass
 
     @abstractmethod
-    def _enum_equality(self, enum_equality: "scout_compute_resolved_api_EnumEqualityRangesNode") -> Any:
+    def _enum_filter(self, enum_filter: "scout_compute_resolved_api_EnumFilterRangesNode") -> Any:
         pass
 
     @abstractmethod
@@ -43942,19 +44144,23 @@ class scout_compute_resolved_api_RangesNodeVisitor:
         pass
 
     @abstractmethod
-    def _not(self, not_: "scout_compute_resolved_api_NotRangesNode") -> Any:
+    def _log_filter(self, log_filter: "scout_compute_resolved_api_LogFilterRangesNode") -> Any:
         pass
 
     @abstractmethod
     def _min_max_threshold(self, min_max_threshold: "scout_compute_resolved_api_MinMaxThresholdRangesNode") -> Any:
         pass
 
+    @abstractmethod
+    def _not(self, not_: "scout_compute_resolved_api_NotRangesNode") -> Any:
+        pass
+
     @abstractmethod
     def _on_change(self, on_change: "scout_compute_resolved_api_OnChangeRangesNode") -> Any:
         pass
 
     @abstractmethod
-    def _threshold(self, threshold: "scout_compute_resolved_api_ThresholdingRangesNode") -> Any:
+    def _range_numeric_aggregation(self, range_numeric_aggregation: "scout_compute_resolved_api_RangesNumericAggregationNode") -> Any:
         pass
 
     @abstractmethod
@@ -43966,15 +44172,15 @@ class scout_compute_resolved_api_RangesNodeVisitor:
         pass
 
     @abstractmethod
-    def _union_range(self, union_range: "scout_compute_resolved_api_UnionRangesNode") -> Any:
+    def _stability_detection(self, stability_detection: "scout_compute_resolved_api_StabilityDetectionRangesNode") -> Any:
         pass
 
     @abstractmethod
-    def _range_numeric_aggregation(self, range_numeric_aggregation: "scout_compute_resolved_api_RangesNumericAggregationNode") -> Any:
+    def _threshold(self, threshold: "scout_compute_resolved_api_ThresholdingRangesNode") -> Any:
         pass
 
     @abstractmethod
-    def _stability_detection(self, stability_detection: "scout_compute_resolved_api_StabilityDetectionRangesNode") -> Any:
+    def _union_range(self, union_range: "scout_compute_resolved_api_UnionRangesNode") -> Any:
         pass
 
 
@@ -44041,6 +44247,29 @@ scout_compute_resolved_api_RawEnumSeriesNode.__qualname__ = "RawEnumSeriesNode"
 scout_compute_resolved_api_RawEnumSeriesNode.__module__ = "nominal_api.scout_compute_resolved_api"
 
 
+class scout_compute_resolved_api_RawLogSeriesNode(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'series': ConjureFieldDefinition('series', scout_compute_api_SeriesSpec)
+        }
+
+    __slots__: List[str] = ['_series']
+
+    def __init__(self, series: "scout_compute_api_SeriesSpec") -> None:
+        self._series = series
+
+    @builtins.property
+    def series(self) -> "scout_compute_api_SeriesSpec":
+        return self._series
+
+
+scout_compute_resolved_api_RawLogSeriesNode.__name__ = "RawLogSeriesNode"
+scout_compute_resolved_api_RawLogSeriesNode.__qualname__ = "RawLogSeriesNode"
+scout_compute_resolved_api_RawLogSeriesNode.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
 class scout_compute_resolved_api_RawNumericSeriesNode(ConjureBeanType):
 
     @builtins.classmethod
@@ -44584,13 +44813,15 @@ class scout_compute_resolved_api_SeriesNode(ConjureUnionType):
     _raw: Optional["scout_compute_resolved_api_RawUntypedSeriesNode"] = None
     _enum: Optional["scout_compute_resolved_api_EnumSeriesNode"] = None
     _numeric: Optional["scout_compute_resolved_api_NumericSeriesNode"] = None
+    _log: Optional["scout_compute_resolved_api_LogSeriesNode"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'raw': ConjureFieldDefinition('raw', scout_compute_resolved_api_RawUntypedSeriesNode),
             'enum': ConjureFieldDefinition('enum', scout_compute_resolved_api_EnumSeriesNode),
-            'numeric': ConjureFieldDefinition('numeric', scout_compute_resolved_api_NumericSeriesNode)
+            'numeric': ConjureFieldDefinition('numeric', scout_compute_resolved_api_NumericSeriesNode),
+            'log': ConjureFieldDefinition('log', scout_compute_resolved_api_LogSeriesNode)
         }
 
     def __init__(
@@ -44598,10 +44829,11 @@ class scout_compute_resolved_api_SeriesNode(ConjureUnionType):
             raw: Optional["scout_compute_resolved_api_RawUntypedSeriesNode"] = None,
             enum: Optional["scout_compute_resolved_api_EnumSeriesNode"] = None,
             numeric: Optional["scout_compute_resolved_api_NumericSeriesNode"] = None,
+            log: Optional["scout_compute_resolved_api_LogSeriesNode"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (raw is not None) + (enum is not None) + (numeric is not None) != 1:
+            if (raw is not None) + (enum is not None) + (numeric is not None) + (log is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if raw is not None:
@@ -44613,6 +44845,9 @@ class scout_compute_resolved_api_SeriesNode(ConjureUnionType):
             if numeric is not None:
                 self._numeric = numeric
                 self._type = 'numeric'
+            if log is not None:
+                self._log = log
+                self._type = 'log'
 
         elif type_of_union == 'raw':
             if raw is None:
@@ -44629,6 +44864,11 @@ class scout_compute_resolved_api_SeriesNode(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._numeric = numeric
             self._type = 'numeric'
+        elif type_of_union == 'log':
+            if log is None:
+                raise ValueError('a union value must not be None')
+            self._log = log
+            self._type = 'log'
 
     @builtins.property
     def raw(self) -> Optional["scout_compute_resolved_api_RawUntypedSeriesNode"]:
@@ -44642,6 +44882,10 @@ class scout_compute_resolved_api_SeriesNode(ConjureUnionType):
     def numeric(self) -> Optional["scout_compute_resolved_api_NumericSeriesNode"]:
         return self._numeric
 
+    @builtins.property
+    def log(self) -> Optional["scout_compute_resolved_api_LogSeriesNode"]:
+        return self._log
+
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, scout_compute_resolved_api_SeriesNodeVisitor):
             raise ValueError('{} is not an instance of scout_compute_resolved_api_SeriesNodeVisitor'.format(visitor.__class__.__name__))
@@ -44651,6 +44895,8 @@ class scout_compute_resolved_api_SeriesNode(ConjureUnionType):
             return visitor._enum(self.enum)
         if self._type == 'numeric' and self.numeric is not None:
             return visitor._numeric(self.numeric)
+        if self._type == 'log' and self.log is not None:
+            return visitor._log(self.log)
 
 
 scout_compute_resolved_api_SeriesNode.__name__ = "SeriesNode"
@@ -44672,6 +44918,10 @@ class scout_compute_resolved_api_SeriesNodeVisitor:
     def _numeric(self, numeric: "scout_compute_resolved_api_NumericSeriesNode") -> Any:
         pass
 
+    @abstractmethod
+    def _log(self, log: "scout_compute_resolved_api_LogSeriesNode") -> Any:
+        pass
+
 
 scout_compute_resolved_api_SeriesNodeVisitor.__name__ = "SeriesNodeVisitor"
 scout_compute_resolved_api_SeriesNodeVisitor.__qualname__ = "SeriesNodeVisitor"
@@ -46083,7 +46333,7 @@ class scout_datareview_api_AutomaticCheckEvaluation(ConjureBeanType):
             'rid': ConjureFieldDefinition('rid', scout_datareview_api_AutomaticCheckEvaluationRid),
             'check_rid': ConjureFieldDefinition('checkRid', scout_rids_api_CheckRid),
             'check_implementation_index': ConjureFieldDefinition('checkImplementationIndex', OptionalTypeWrapper[int]),
-            'data_review_rid': ConjureFieldDefinition('dataReviewRid', scout_datareview_api_DataReviewRid),
+            'data_review_rid': ConjureFieldDefinition('dataReviewRid', scout_rids_api_DataReviewRid),
             'state': ConjureFieldDefinition('state', scout_datareview_api_AutomaticCheckEvaluationState)
         }
 
@@ -46789,7 +47039,7 @@ class scout_datareview_api_BatchCheckAlertActionRequest(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'check_alert_action': ConjureFieldDefinition('checkAlertAction', scout_datareview_api_CheckAlertAction),
-            'check_alert_rids': ConjureFieldDefinition('checkAlertRids', List[scout_datareview_api_CheckAlertRid])
+            'check_alert_rids': ConjureFieldDefinition('checkAlertRids', List[scout_rids_api_CheckAlertRid])
         }
 
     __slots__: List[str] = ['_check_alert_action', '_check_alert_rids']
@@ -46875,7 +47125,7 @@ class scout_datareview_api_BatchInitiateDataReviewResponse(ConjureBeanType):
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'rids': ConjureFieldDefinition('rids', List[scout_datareview_api_DataReviewRid])
+            'rids': ConjureFieldDefinition('rids', List[scout_rids_api_DataReviewRid])
         }
 
     __slots__: List[str] = ['_rids']
@@ -46927,10 +47177,10 @@ class scout_datareview_api_CheckAlert(ConjureBeanType):
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'rid': ConjureFieldDefinition('rid', scout_datareview_api_CheckAlertRid),
+            'rid': ConjureFieldDefinition('rid', scout_rids_api_CheckAlertRid),
             'check_rid': ConjureFieldDefinition('checkRid', scout_rids_api_CheckRid),
             'implementation_index': ConjureFieldDefinition('implementationIndex', OptionalTypeWrapper[int]),
-            'data_review_rid': ConjureFieldDefinition('dataReviewRid', scout_datareview_api_DataReviewRid),
+            'data_review_rid': ConjureFieldDefinition('dataReviewRid', scout_rids_api_DataReviewRid),
             'check_evaluation_rid': ConjureFieldDefinition('checkEvaluationRid', scout_datareview_api_AutomaticCheckEvaluationRid),
             'name': ConjureFieldDefinition('name', str),
             'autogenerated_check_title': ConjureFieldDefinition('autogeneratedCheckTitle', OptionalTypeWrapper[str]),
@@ -47448,7 +47698,7 @@ class scout_datareview_api_CheckAlertsHistogramRequest(ConjureBeanType):
             'start_time_before': ConjureFieldDefinition('startTimeBefore', api_Timestamp),
             'status': ConjureFieldDefinition('status', OptionalTypeWrapper[List[scout_datareview_api_CheckAlertStatus]]),
             'check_rids': ConjureFieldDefinition('checkRids', OptionalTypeWrapper[List[scout_rids_api_CheckRid]]),
-            'data_review_rids': ConjureFieldDefinition('dataReviewRids', OptionalTypeWrapper[List[scout_datareview_api_DataReviewRid]]),
+            'data_review_rids': ConjureFieldDefinition('dataReviewRids', OptionalTypeWrapper[List[scout_rids_api_DataReviewRid]]),
             'assignee_rids': ConjureFieldDefinition('assigneeRids', OptionalTypeWrapper[List[scout_rids_api_UserRid]]),
             'priorities': ConjureFieldDefinition('priorities', OptionalTypeWrapper[List[scout_checks_api_Priority]]),
             'run_rids': ConjureFieldDefinition('runRids', List[scout_run_api_RunRid]),
@@ -47761,7 +48011,7 @@ class scout_datareview_api_ChecklistEvaluation(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'checklist': ConjureFieldDefinition('checklist', scout_checks_api_PinnedChecklistRef),
-            'data_review_rid': ConjureFieldDefinition('dataReviewRid', scout_datareview_api_DataReviewRid),
+            'data_review_rid': ConjureFieldDefinition('dataReviewRid', scout_rids_api_DataReviewRid),
             'checks': ConjureFieldDefinition('checks', List[scout_datareview_api_CheckEvaluation])
         }
 
@@ -48197,7 +48447,7 @@ class scout_datareview_api_DataReview(ConjureBeanType):
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'rid': ConjureFieldDefinition('rid', scout_datareview_api_DataReviewRid),
+            'rid': ConjureFieldDefinition('rid', scout_rids_api_DataReviewRid),
             'run_rid': ConjureFieldDefinition('runRid', scout_run_api_RunRid),
             'created_at': ConjureFieldDefinition('createdAt', str),
             'created_by': ConjureFieldDefinition('createdBy', scout_rids_api_UserRid),
@@ -49113,7 +49363,7 @@ class scout_datareview_api_GeneratedAlertsState(ConjureBeanType):
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'rids': ConjureFieldDefinition('rids', List[scout_datareview_api_CheckAlertRid])
+            'rids': ConjureFieldDefinition('rids', List[scout_rids_api_CheckAlertRid])
         }
 
     __slots__: List[str] = ['_rids']
@@ -49732,7 +49982,7 @@ class scout_datareview_api_ManualCheckEvaluation(ConjureBeanType):
         return {
             'rid': ConjureFieldDefinition('rid', scout_datareview_api_ManualCheckEvaluationRid),
             'check_rid': ConjureFieldDefinition('checkRid', scout_rids_api_CheckRid),
-            'data_review_rid': ConjureFieldDefinition('dataReviewRid', scout_datareview_api_DataReviewRid),
+            'data_review_rid': ConjureFieldDefinition('dataReviewRid', scout_rids_api_DataReviewRid),
             'state': ConjureFieldDefinition('state', scout_datareview_api_ManualCheckEvaluationState),
             'assignee_rids': ConjureFieldDefinition('assigneeRids', List[scout_rids_api_UserRid]),
             'chart': ConjureFieldDefinition('chart', OptionalTypeWrapper[scout_rids_api_VersionedVizId]),
@@ -50298,7 +50548,7 @@ class scout_datareview_api_RerunFailedAutomaticChecksRequest(ConjureBeanType):
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'data_review_rid': ConjureFieldDefinition('dataReviewRid', scout_datareview_api_DataReviewRid)
+            'data_review_rid': ConjureFieldDefinition('dataReviewRid', scout_rids_api_DataReviewRid)
         }
 
     __slots__: List[str] = ['_data_review_rid']
@@ -50329,7 +50579,7 @@ class scout_datareview_api_SearchCheckAlertsRequest(ConjureBeanType):
             'before': ConjureFieldDefinition('before', OptionalTypeWrapper[api_Timestamp]),
             'status': ConjureFieldDefinition('status', OptionalTypeWrapper[List[scout_datareview_api_CheckAlertStatus]]),
             'check_rids': ConjureFieldDefinition('checkRids', OptionalTypeWrapper[List[scout_rids_api_CheckRid]]),
-            'data_review_rids': ConjureFieldDefinition('dataReviewRids', OptionalTypeWrapper[List[scout_datareview_api_DataReviewRid]]),
+            'data_review_rids': ConjureFieldDefinition('dataReviewRids', OptionalTypeWrapper[List[scout_rids_api_DataReviewRid]]),
             'assignee_rids': ConjureFieldDefinition('assigneeRids', OptionalTypeWrapper[List[scout_rids_api_UserRid]]),
             'priorities': ConjureFieldDefinition('priorities', OptionalTypeWrapper[List[scout_checks_api_Priority]]),
             'run_rids': ConjureFieldDefinition('runRids', List[scout_run_api_RunRid]),
@@ -69092,8 +69342,6 @@ authentication_api_OrgRid = str
 
 themes_api_ChartThemeRid = str
 
-scout_datareview_api_DataReviewRid = str
-
 scout_rids_api_SnapshotRid = str
 
 scout_units_api_UnitName = str
@@ -69150,6 +69398,8 @@ scout_compute_api_ErrorCode = int
 
 api_rids_ChunkRid = str
 
+scout_rids_api_CheckAlertRid = str
+
 datasource_Token = str
 
 scout_chart_api_JsonString = str
@@ -69164,6 +69414,8 @@ datasource_pagination_api_PageToken = str
 
 scout_datasource_connection_api_ProjectName = str
 
+scout_rids_api_DataReviewRid = str
+
 api_rids_SegmentRid = str
 
 scout_comparisonnotebook_api_VariableName = str
@@ -69222,8 +69474,6 @@ scout_rids_api_UserRid = str
 
 api_rids_DatasetRid = str
 
-scout_datareview_api_CheckAlertRid = str
-
 scout_units_api_UnitSymbol = str
 
 datasource_logset_api_Token = str