nominal-api 0.540.1__py3-none-any.whl → 0.542.0__py3-none-any.whl

nominal_api/_impl.py

@@ -10726,105 +10726,6 @@ includes metrics for check and violation review status
         _decoder = ConjureDecoder()
         return _decoder.decode(_response.json(), scout_run_api_SearchRunChannelsResponse, self._return_none_for_unknown_union_types)
 
-    def get_events(self, auth_header: str, rid: str, next_page_token: Optional[str] = None) -> "scout_run_api_GetEventsForRunPage":
-        """
-        Fetches a list of events associated with the run.
-
-Returns a maximum page size of 1000.
-        """
-
-        _headers: Dict[str, Any] = {
-            'Accept': 'application/json',
-            'Authorization': auth_header,
-        }
-
-        _params: Dict[str, Any] = {
-            'nextPageToken': next_page_token,
-        }
-
-        _path_params: Dict[str, Any] = {
-            'rid': rid,
-        }
-
-        _json: Any = None
-
-        _path = '/scout/v1/run/{rid}/events'
-        _path = _path.format(**_path_params)
-
-        _response: Response = self._request(
-            'GET',
-            self._uri + _path,
-            params=_params,
-            headers=_headers,
-            json=_json)
-
-        _decoder = ConjureDecoder()
-        return _decoder.decode(_response.json(), scout_run_api_GetEventsForRunPage, self._return_none_for_unknown_union_types)
-
-    def publish_events(self, auth_header: str, request: "scout_run_api_PublishEventsToRunRequest", rid: str) -> None:
-        """
-        Adds a set of new events to the run.
-        """
-
-        _headers: Dict[str, Any] = {
-            'Accept': 'application/json',
-            'Content-Type': 'application/json',
-            'Authorization': auth_header,
-        }
-
-        _params: Dict[str, Any] = {
-        }
-
-        _path_params: Dict[str, Any] = {
-            'rid': rid,
-        }
-
-        _json: Any = ConjureEncoder().default(request)
-
-        _path = '/scout/v1/run/{rid}/events'
-        _path = _path.format(**_path_params)
-
-        _response: Response = self._request(
-            'POST',
-            self._uri + _path,
-            params=_params,
-            headers=_headers,
-            json=_json)
-
-        return
-
-    def delete_events_from_run(self, auth_header: str, request: "scout_run_api_DeleteEventsFromRunRequest", rid: str) -> None:
-        """
-        Deletes events from the run.
-        """
-
-        _headers: Dict[str, Any] = {
-            'Accept': 'application/json',
-            'Content-Type': 'application/json',
-            'Authorization': auth_header,
-        }
-
-        _params: Dict[str, Any] = {
-        }
-
-        _path_params: Dict[str, Any] = {
-            'rid': rid,
-        }
-
-        _json: Any = ConjureEncoder().default(request)
-
-        _path = '/scout/v1/run/{rid}/delete-events'
-        _path = _path.format(**_path_params)
-
-        _response: Response = self._request(
-            'POST',
-            self._uri + _path,
-            params=_params,
-            headers=_headers,
-            json=_json)
-
-        return
-
     def update_run_attachment(self, auth_header: str, request: "scout_run_api_UpdateAttachmentsRequest", rid: str) -> None:
         """
         Updates the attachments associated with a run.
@@ -27603,6 +27504,64 @@ scout_compute_api_Average.__qualname__ = "Average"
 scout_compute_api_Average.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_BandPassConfiguration(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'low_passband_frequency': ConjureFieldDefinition('lowPassbandFrequency', scout_compute_api_DoubleConstant),
+            'high_passband_frequency': ConjureFieldDefinition('highPassbandFrequency', scout_compute_api_DoubleConstant)
+        }
+
+    __slots__: List[str] = ['_low_passband_frequency', '_high_passband_frequency']
+
+    def __init__(self, high_passband_frequency: "scout_compute_api_DoubleConstant", low_passband_frequency: "scout_compute_api_DoubleConstant") -> None:
+        self._low_passband_frequency = low_passband_frequency
+        self._high_passband_frequency = high_passband_frequency
+
+    @builtins.property
+    def low_passband_frequency(self) -> "scout_compute_api_DoubleConstant":
+        return self._low_passband_frequency
+
+    @builtins.property
+    def high_passband_frequency(self) -> "scout_compute_api_DoubleConstant":
+        return self._high_passband_frequency
+
+
+scout_compute_api_BandPassConfiguration.__name__ = "BandPassConfiguration"
+scout_compute_api_BandPassConfiguration.__qualname__ = "BandPassConfiguration"
+scout_compute_api_BandPassConfiguration.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_BandStopConfiguration(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'low_stopband_frequency': ConjureFieldDefinition('lowStopbandFrequency', scout_compute_api_DoubleConstant),
+            'high_stopband_frequency': ConjureFieldDefinition('highStopbandFrequency', scout_compute_api_DoubleConstant)
+        }
+
+    __slots__: List[str] = ['_low_stopband_frequency', '_high_stopband_frequency']
+
+    def __init__(self, high_stopband_frequency: "scout_compute_api_DoubleConstant", low_stopband_frequency: "scout_compute_api_DoubleConstant") -> None:
+        self._low_stopband_frequency = low_stopband_frequency
+        self._high_stopband_frequency = high_stopband_frequency
+
+    @builtins.property
+    def low_stopband_frequency(self) -> "scout_compute_api_DoubleConstant":
+        return self._low_stopband_frequency
+
+    @builtins.property
+    def high_stopband_frequency(self) -> "scout_compute_api_DoubleConstant":
+        return self._high_stopband_frequency
+
+
+scout_compute_api_BandStopConfiguration.__name__ = "BandStopConfiguration"
+scout_compute_api_BandStopConfiguration.__qualname__ = "BandStopConfiguration"
+scout_compute_api_BandStopConfiguration.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_BatchComputeUnitResult(ConjureBeanType):
 
     @builtins.classmethod
@@ -28920,6 +28879,7 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
     _bucketed_geo: Optional["scout_compute_api_BucketedGeoPlot"] = None
     _enum_point: Optional[Optional["scout_compute_api_EnumPoint"]] = None
     _numeric_point: Optional[Optional["scout_compute_api_NumericPoint"]] = None
+    _log_point: Optional[Optional["scout_compute_api_LogPoint"]] = None
     _range_value: Optional[Optional["scout_compute_api_Range"]] = None
     _frequency_domain: Optional["scout_compute_api_FrequencyDomainPlot"] = None
     _numeric_histogram: Optional["scout_compute_api_NumericHistogramPlot"] = None
@@ -28940,6 +28900,7 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
             'bucketed_geo': ConjureFieldDefinition('bucketedGeo', scout_compute_api_BucketedGeoPlot),
             'enum_point': ConjureFieldDefinition('enumPoint', OptionalTypeWrapper[scout_compute_api_EnumPoint]),
             'numeric_point': ConjureFieldDefinition('numericPoint', OptionalTypeWrapper[scout_compute_api_NumericPoint]),
+            'log_point': ConjureFieldDefinition('logPoint', OptionalTypeWrapper[scout_compute_api_LogPoint]),
             'range_value': ConjureFieldDefinition('rangeValue', OptionalTypeWrapper[scout_compute_api_Range]),
             'frequency_domain': ConjureFieldDefinition('frequencyDomain', scout_compute_api_FrequencyDomainPlot),
             'numeric_histogram': ConjureFieldDefinition('numericHistogram', scout_compute_api_NumericHistogramPlot),
@@ -28960,6 +28921,7 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
             bucketed_geo: Optional["scout_compute_api_BucketedGeoPlot"] = None,
             enum_point: Optional[Optional["scout_compute_api_EnumPoint"]] = None,
             numeric_point: Optional[Optional["scout_compute_api_NumericPoint"]] = None,
+            log_point: Optional[Optional["scout_compute_api_LogPoint"]] = None,
             range_value: Optional[Optional["scout_compute_api_Range"]] = None,
             frequency_domain: Optional["scout_compute_api_FrequencyDomainPlot"] = None,
             numeric_histogram: Optional["scout_compute_api_NumericHistogramPlot"] = None,
@@ -28967,7 +28929,7 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (numeric is not None) + (bucketed_numeric is not None) + (range is not None) + (ranges_summary is not None) + (enum is not None) + (log is not None) + (bucketed_enum is not None) + (cartesian is not None) + (bucketed_cartesian is not None) + (bucketed_geo is not None) + (enum_point is not None) + (numeric_point is not None) + (range_value is not None) + (frequency_domain is not None) + (numeric_histogram is not None) + (enum_histogram is not None) != 1:
+            if (numeric is not None) + (bucketed_numeric is not None) + (range is not None) + (ranges_summary is not None) + (enum is not None) + (log is not None) + (bucketed_enum is not None) + (cartesian is not None) + (bucketed_cartesian is not None) + (bucketed_geo is not None) + (enum_point is not None) + (numeric_point is not None) + (log_point is not None) + (range_value is not None) + (frequency_domain is not None) + (numeric_histogram is not None) + (enum_histogram is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if numeric is not None:
@@ -29006,6 +28968,9 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
             if numeric_point is not None:
                 self._numeric_point = numeric_point
                 self._type = 'numericPoint'
+            if log_point is not None:
+                self._log_point = log_point
+                self._type = 'logPoint'
             if range_value is not None:
                 self._range_value = range_value
                 self._type = 'rangeValue'
@@ -29079,6 +29044,11 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._numeric_point = numeric_point
             self._type = 'numericPoint'
+        elif type_of_union == 'logPoint':
+            if log_point is None:
+                raise ValueError('a union value must not be None')
+            self._log_point = log_point
+            self._type = 'logPoint'
         elif type_of_union == 'rangeValue':
             if range_value is None:
                 raise ValueError('a union value must not be None')
@@ -29148,6 +29118,10 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
     def numeric_point(self) -> Optional[Optional["scout_compute_api_NumericPoint"]]:
         return self._numeric_point
 
+    @builtins.property
+    def log_point(self) -> Optional[Optional["scout_compute_api_LogPoint"]]:
+        return self._log_point
+
     @builtins.property
     def range_value(self) -> Optional[Optional["scout_compute_api_Range"]]:
         return self._range_value
@@ -29191,6 +29165,8 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
             return visitor._enum_point(self.enum_point)
         if self._type == 'numericPoint' and self.numeric_point is not None:
             return visitor._numeric_point(self.numeric_point)
+        if self._type == 'logPoint' and self.log_point is not None:
+            return visitor._log_point(self.log_point)
         if self._type == 'rangeValue' and self.range_value is not None:
             return visitor._range_value(self.range_value)
         if self._type == 'frequencyDomain' and self.frequency_domain is not None:
@@ -29256,6 +29232,10 @@ class scout_compute_api_ComputeNodeResponseVisitor:
     def _numeric_point(self, numeric_point: Optional["scout_compute_api_NumericPoint"]) -> Any:
         pass
 
+    @abstractmethod
+    def _log_point(self, log_point: Optional["scout_compute_api_LogPoint"]) -> Any:
+        pass
+
     @abstractmethod
     def _range_value(self, range_value: Optional["scout_compute_api_Range"]) -> Any:
         pass
@@ -31475,6 +31455,29 @@ scout_compute_api_GeoTimeBucket.__qualname__ = "GeoTimeBucket"
 scout_compute_api_GeoTimeBucket.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_HighPassConfiguration(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'cutoff_frequency': ConjureFieldDefinition('cutoffFrequency', scout_compute_api_DoubleConstant)
+        }
+
+    __slots__: List[str] = ['_cutoff_frequency']
+
+    def __init__(self, cutoff_frequency: "scout_compute_api_DoubleConstant") -> None:
+        self._cutoff_frequency = cutoff_frequency
+
+    @builtins.property
+    def cutoff_frequency(self) -> "scout_compute_api_DoubleConstant":
+        return self._cutoff_frequency
+
+
+scout_compute_api_HighPassConfiguration.__name__ = "HighPassConfiguration"
+scout_compute_api_HighPassConfiguration.__qualname__ = "HighPassConfiguration"
+scout_compute_api_HighPassConfiguration.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_Histogram(ConjureUnionType):
     _numeric: Optional["scout_compute_api_NumericHistogramNode"] = None
     _enum: Optional["scout_compute_api_EnumHistogramNode"] = None
@@ -31913,190 +31916,30 @@ scout_compute_api_LatLongPoint.__qualname__ = "LatLongPoint"
 scout_compute_api_LatLongPoint.__module__ = "nominal_api.scout_compute_api"
 
 
-class scout_compute_api_LogAssetChannel(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'asset_rid': ConjureFieldDefinition('assetRid', scout_compute_api_StringConstant),
-            'data_scope_name': ConjureFieldDefinition('dataScopeName', scout_compute_api_StringConstant),
-            'channel': ConjureFieldDefinition('channel', scout_compute_api_StringConstant),
-            'additional_filters': ConjureFieldDefinition('additionalFilters', Dict[str, scout_compute_api_StringConstant])
-        }
-
-    __slots__: List[str] = ['_asset_rid', '_data_scope_name', '_channel', '_additional_filters']
-
-    def __init__(self, additional_filters: Dict[str, "scout_compute_api_StringConstant"], asset_rid: "scout_compute_api_StringConstant", channel: "scout_compute_api_StringConstant", data_scope_name: "scout_compute_api_StringConstant") -> None:
-        self._asset_rid = asset_rid
-        self._data_scope_name = data_scope_name
-        self._channel = channel
-        self._additional_filters = additional_filters
-
-    @builtins.property
-    def asset_rid(self) -> "scout_compute_api_StringConstant":
-        return self._asset_rid
-
-    @builtins.property
-    def data_scope_name(self) -> "scout_compute_api_StringConstant":
-        """
-        Used to disambiguate when multiple data scopes within this asset contain channels with the same name.
-        """
-        return self._data_scope_name
-
-    @builtins.property
-    def channel(self) -> "scout_compute_api_StringConstant":
-        return self._channel
-
-    @builtins.property
-    def additional_filters(self) -> Dict[str, "scout_compute_api_StringConstant"]:
-        """
-        Filters by which to filter the log channel, 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 filters.
-        """
-        return self._additional_filters
-
-
-scout_compute_api_LogAssetChannel.__name__ = "LogAssetChannel"
-scout_compute_api_LogAssetChannel.__qualname__ = "LogAssetChannel"
-scout_compute_api_LogAssetChannel.__module__ = "nominal_api.scout_compute_api"
-
-
-class scout_compute_api_LogChannelSeries(ConjureUnionType):
-    _data_source: Optional["scout_compute_api_LogDataSourceChannel"] = None
-    _asset: Optional["scout_compute_api_LogAssetChannel"] = None
-    _run: Optional["scout_compute_api_LogRunChannel"] = None
-
-    @builtins.classmethod
-    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'data_source': ConjureFieldDefinition('dataSource', scout_compute_api_LogDataSourceChannel),
-            'asset': ConjureFieldDefinition('asset', scout_compute_api_LogAssetChannel),
-            'run': ConjureFieldDefinition('run', scout_compute_api_LogRunChannel)
-        }
-
-    def __init__(
-            self,
-            data_source: Optional["scout_compute_api_LogDataSourceChannel"] = None,
-            asset: Optional["scout_compute_api_LogAssetChannel"] = None,
-            run: Optional["scout_compute_api_LogRunChannel"] = None,
-            type_of_union: Optional[str] = None
-            ) -> None:
-        if type_of_union is None:
-            if (data_source is not None) + (asset is not None) + (run is not None) != 1:
-                raise ValueError('a union must contain a single member')
-
-            if data_source is not None:
-                self._data_source = data_source
-                self._type = 'dataSource'
-            if asset is not None:
-                self._asset = asset
-                self._type = 'asset'
-            if run is not None:
-                self._run = run
-                self._type = 'run'
-
-        elif type_of_union == 'dataSource':
-            if data_source is None:
-                raise ValueError('a union value must not be None')
-            self._data_source = data_source
-            self._type = 'dataSource'
-        elif type_of_union == 'asset':
-            if asset is None:
-                raise ValueError('a union value must not be None')
-            self._asset = asset
-            self._type = 'asset'
-        elif type_of_union == 'run':
-            if run is None:
-                raise ValueError('a union value must not be None')
-            self._run = run
-            self._type = 'run'
-
-    @builtins.property
-    def data_source(self) -> Optional["scout_compute_api_LogDataSourceChannel"]:
-        return self._data_source
-
-    @builtins.property
-    def asset(self) -> Optional["scout_compute_api_LogAssetChannel"]:
-        return self._asset
-
-    @builtins.property
-    def run(self) -> Optional["scout_compute_api_LogRunChannel"]:
-        return self._run
-
-    def accept(self, visitor) -> Any:
-        if not isinstance(visitor, scout_compute_api_LogChannelSeriesVisitor):
-            raise ValueError('{} is not an instance of scout_compute_api_LogChannelSeriesVisitor'.format(visitor.__class__.__name__))
-        if self._type == 'dataSource' and self.data_source is not None:
-            return visitor._data_source(self.data_source)
-        if self._type == 'asset' and self.asset is not None:
-            return visitor._asset(self.asset)
-        if self._type == 'run' and self.run is not None:
-            return visitor._run(self.run)
-
-
-scout_compute_api_LogChannelSeries.__name__ = "LogChannelSeries"
-scout_compute_api_LogChannelSeries.__qualname__ = "LogChannelSeries"
-scout_compute_api_LogChannelSeries.__module__ = "nominal_api.scout_compute_api"
-
-
-class scout_compute_api_LogChannelSeriesVisitor:
-
-    @abstractmethod
-    def _data_source(self, data_source: "scout_compute_api_LogDataSourceChannel") -> Any:
-        pass
-
-    @abstractmethod
-    def _asset(self, asset: "scout_compute_api_LogAssetChannel") -> Any:
-        pass
-
-    @abstractmethod
-    def _run(self, run: "scout_compute_api_LogRunChannel") -> Any:
-        pass
-
-
-scout_compute_api_LogChannelSeriesVisitor.__name__ = "LogChannelSeriesVisitor"
-scout_compute_api_LogChannelSeriesVisitor.__qualname__ = "LogChannelSeriesVisitor"
-scout_compute_api_LogChannelSeriesVisitor.__module__ = "nominal_api.scout_compute_api"
-
-
-class scout_compute_api_LogDataSourceChannel(ConjureBeanType):
+class scout_compute_api_LogArgFilterOperator(ConjureBeanType):
+    """
+    Outputs a new series where the log message in each point contains all of the given arg key-value pairs.
+    """
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'data_source_rid': ConjureFieldDefinition('dataSourceRid', scout_compute_api_StringConstant),
-            'channel': ConjureFieldDefinition('channel', scout_compute_api_StringConstant),
-            'filters': ConjureFieldDefinition('filters', Dict[str, scout_compute_api_StringConstant])
+            'args': ConjureFieldDefinition('args', Dict[str, scout_compute_api_StringConstant])
         }
 
-    __slots__: List[str] = ['_data_source_rid', '_channel', '_filters']
-
-    def __init__(self, channel: "scout_compute_api_StringConstant", data_source_rid: "scout_compute_api_StringConstant", filters: Dict[str, "scout_compute_api_StringConstant"]) -> None:
-        self._data_source_rid = data_source_rid
-        self._channel = channel
-        self._filters = filters
-
-    @builtins.property
-    def data_source_rid(self) -> "scout_compute_api_StringConstant":
-        return self._data_source_rid
+    __slots__: List[str] = ['_args']
 
-    @builtins.property
-    def channel(self) -> "scout_compute_api_StringConstant":
-        return self._channel
+    def __init__(self, args: Dict[str, "scout_compute_api_StringConstant"]) -> None:
+        self._args = args
 
     @builtins.property
-    def filters(self) -> Dict[str, "scout_compute_api_StringConstant"]:
-        """
-        Filters by which to filter the log channel. Only returns points from the channel with matching values for
-the provided keys.
-        """
-        return self._filters
+    def args(self) -> Dict[str, "scout_compute_api_StringConstant"]:
+        return self._args
 
 
-scout_compute_api_LogDataSourceChannel.__name__ = "LogDataSourceChannel"
-scout_compute_api_LogDataSourceChannel.__qualname__ = "LogDataSourceChannel"
-scout_compute_api_LogDataSourceChannel.__module__ = "nominal_api.scout_compute_api"
+scout_compute_api_LogArgFilterOperator.__name__ = "LogArgFilterOperator"
+scout_compute_api_LogArgFilterOperator.__qualname__ = "LogArgFilterOperator"
+scout_compute_api_LogArgFilterOperator.__module__ = "nominal_api.scout_compute_api"
 
 
 class scout_compute_api_LogPlot(ConjureBeanType):
@@ -32105,12 +31948,12 @@ class scout_compute_api_LogPlot(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'timestamps': ConjureFieldDefinition('timestamps', List[api_Timestamp]),
-            'values': ConjureFieldDefinition('values', List[str])
+            'values': ConjureFieldDefinition('values', List[scout_compute_api_LogValue])
         }
 
     __slots__: List[str] = ['_timestamps', '_values']
 
-    def __init__(self, timestamps: List["api_Timestamp"], values: List[str]) -> None:
+    def __init__(self, timestamps: List["api_Timestamp"], values: List["scout_compute_api_LogValue"]) -> None:
         self._timestamps = timestamps
         self._values = values
 
@@ -32119,7 +31962,7 @@ class scout_compute_api_LogPlot(ConjureBeanType):
         return self._timestamps
 
     @builtins.property
-    def values(self) -> List[str]:
+    def values(self) -> List["scout_compute_api_LogValue"]:
         return self._values
 
 
@@ -32128,91 +31971,65 @@ scout_compute_api_LogPlot.__qualname__ = "LogPlot"
 scout_compute_api_LogPlot.__module__ = "nominal_api.scout_compute_api"
 
 
-class scout_compute_api_LogRegexFilterSeries(ConjureBeanType):
-    """
-    Outputs a new series where the log message in each point satisfies the given re2 regular expression filter.
-Regular expression syntax: https://github.com/google/re2/wiki/Syntax.
-    """
+class scout_compute_api_LogPoint(ConjureBeanType):
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'input': ConjureFieldDefinition('input', scout_compute_api_LogSeries),
-            'regex': ConjureFieldDefinition('regex', scout_compute_api_StringConstant)
+            'timestamp': ConjureFieldDefinition('timestamp', api_Timestamp),
+            'value': ConjureFieldDefinition('value', scout_compute_api_LogValue)
         }
 
-    __slots__: List[str] = ['_input', '_regex']
+    __slots__: List[str] = ['_timestamp', '_value']
 
-    def __init__(self, input: "scout_compute_api_LogSeries", regex: "scout_compute_api_StringConstant") -> None:
-        self._input = input
-        self._regex = regex
+    def __init__(self, timestamp: "api_Timestamp", value: "scout_compute_api_LogValue") -> None:
+        self._timestamp = timestamp
+        self._value = value
 
     @builtins.property
-    def input(self) -> "scout_compute_api_LogSeries":
-        return self._input
+    def timestamp(self) -> "api_Timestamp":
+        return self._timestamp
 
     @builtins.property
-    def regex(self) -> "scout_compute_api_StringConstant":
-        return self._regex
+    def value(self) -> "scout_compute_api_LogValue":
+        return self._value
 
 
-scout_compute_api_LogRegexFilterSeries.__name__ = "LogRegexFilterSeries"
-scout_compute_api_LogRegexFilterSeries.__qualname__ = "LogRegexFilterSeries"
-scout_compute_api_LogRegexFilterSeries.__module__ = "nominal_api.scout_compute_api"
+scout_compute_api_LogPoint.__name__ = "LogPoint"
+scout_compute_api_LogPoint.__qualname__ = "LogPoint"
+scout_compute_api_LogPoint.__module__ = "nominal_api.scout_compute_api"
 
 
-class scout_compute_api_LogRunChannel(ConjureBeanType):
+class scout_compute_api_LogRegexFilterOperator(ConjureBeanType):
+    """
+    Outputs a new series where 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 {
-            'run_rid': ConjureFieldDefinition('runRid', scout_compute_api_StringConstant),
-            'data_scope_name': ConjureFieldDefinition('dataScopeName', scout_compute_api_StringConstant),
-            'channel': ConjureFieldDefinition('channel', scout_compute_api_StringConstant),
-            'additional_filters': ConjureFieldDefinition('additionalFilters', Dict[str, scout_compute_api_StringConstant])
+            'regex': ConjureFieldDefinition('regex', scout_compute_api_StringConstant)
         }
 
-    __slots__: List[str] = ['_run_rid', '_data_scope_name', '_channel', '_additional_filters']
-
-    def __init__(self, additional_filters: Dict[str, "scout_compute_api_StringConstant"], channel: "scout_compute_api_StringConstant", data_scope_name: "scout_compute_api_StringConstant", run_rid: "scout_compute_api_StringConstant") -> None:
-        self._run_rid = run_rid
-        self._data_scope_name = data_scope_name
-        self._channel = channel
-        self._additional_filters = additional_filters
+    __slots__: List[str] = ['_regex']
 
-    @builtins.property
-    def run_rid(self) -> "scout_compute_api_StringConstant":
-        return self._run_rid
-
-    @builtins.property
-    def data_scope_name(self) -> "scout_compute_api_StringConstant":
-        """
-        Used to disambiguate when multiple data scopes within this run contain channels with the same name.
-        """
-        return self._data_scope_name
-
-    @builtins.property
-    def channel(self) -> "scout_compute_api_StringConstant":
-        return self._channel
+    def __init__(self, regex: "scout_compute_api_StringConstant") -> None:
+        self._regex = regex
 
     @builtins.property
-    def additional_filters(self) -> Dict[str, "scout_compute_api_StringConstant"]:
-        """
-        Filters by which to filter the log channel, 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 filters.
-        """
-        return self._additional_filters
+    def regex(self) -> "scout_compute_api_StringConstant":
+        return self._regex
 
 
-scout_compute_api_LogRunChannel.__name__ = "LogRunChannel"
-scout_compute_api_LogRunChannel.__qualname__ = "LogRunChannel"
-scout_compute_api_LogRunChannel.__module__ = "nominal_api.scout_compute_api"
+scout_compute_api_LogRegexFilterOperator.__name__ = "LogRegexFilterOperator"
+scout_compute_api_LogRegexFilterOperator.__qualname__ = "LogRegexFilterOperator"
+scout_compute_api_LogRegexFilterOperator.__module__ = "nominal_api.scout_compute_api"
 
 
 class scout_compute_api_LogSeries(ConjureUnionType):
     _raw: Optional["scout_compute_api_Reference"] = None
-    _channel: Optional["scout_compute_api_LogChannelSeries"] = 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
@@ -32221,7 +32038,7 @@ class scout_compute_api_LogSeries(ConjureUnionType):
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'raw': ConjureFieldDefinition('raw', scout_compute_api_Reference),
-            'channel': ConjureFieldDefinition('channel', scout_compute_api_LogChannelSeries),
+            '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)
@@ -32230,7 +32047,7 @@ class scout_compute_api_LogSeries(ConjureUnionType):
     def __init__(
             self,
             raw: Optional["scout_compute_api_Reference"] = None,
-            channel: Optional["scout_compute_api_LogChannelSeries"] = 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,
@@ -32287,7 +32104,7 @@ class scout_compute_api_LogSeries(ConjureUnionType):
         return self._raw
 
     @builtins.property
-    def channel(self) -> Optional["scout_compute_api_LogChannelSeries"]:
+    def channel(self) -> Optional["scout_compute_api_ChannelSeries"]:
         return self._channel
 
     @builtins.property
@@ -32329,7 +32146,7 @@ class scout_compute_api_LogSeriesVisitor:
         pass
 
     @abstractmethod
-    def _channel(self, channel: "scout_compute_api_LogChannelSeries") -> Any:
+    def _channel(self, channel: "scout_compute_api_ChannelSeries") -> Any:
         pass
 
     @abstractmethod
@@ -32446,28 +32263,68 @@ scout_compute_api_LogUnionSeries.__qualname__ = "LogUnionSeries"
 scout_compute_api_LogUnionSeries.__module__ = "nominal_api.scout_compute_api"
 
 
-class scout_compute_api_LogValueFilterSeries(ConjureUnionType):
-    _regex_filter: Optional["scout_compute_api_LogRegexFilterSeries"] = None
+class scout_compute_api_LogValue(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'message': ConjureFieldDefinition('message', str),
+            'args': ConjureFieldDefinition('args', Dict[str, str])
+        }
+
+    __slots__: List[str] = ['_message', '_args']
+
+    def __init__(self, args: Dict[str, str], message: str) -> None:
+        self._message = message
+        self._args = args
+
+    @builtins.property
+    def message(self) -> str:
+        return self._message
+
+    @builtins.property
+    def args(self) -> Dict[str, str]:
+        return self._args
+
+
+scout_compute_api_LogValue.__name__ = "LogValue"
+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 {
-            'regex_filter': ConjureFieldDefinition('regexFilter', scout_compute_api_LogRegexFilterSeries)
+            'arg_filter': ConjureFieldDefinition('argFilter', scout_compute_api_LogArgFilterOperator),
+            'regex_filter': ConjureFieldDefinition('regexFilter', scout_compute_api_LogRegexFilterOperator)
         }
 
     def __init__(
             self,
-            regex_filter: Optional["scout_compute_api_LogRegexFilterSeries"] = None,
+            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 (regex_filter is not None) != 1:
+            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')
@@ -32475,31 +32332,93 @@ class scout_compute_api_LogValueFilterSeries(ConjureUnionType):
             self._type = 'regexFilter'
 
     @builtins.property
-    def regex_filter(self) -> Optional["scout_compute_api_LogRegexFilterSeries"]:
+    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_LogValueFilterSeriesVisitor):
-            raise ValueError('{} is not an instance of scout_compute_api_LogValueFilterSeriesVisitor'.format(visitor.__class__.__name__))
+        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_LogValueFilterSeriesVisitor:
+class scout_compute_api_LowPassConfiguration(ConjureBeanType):
 
-    @abstractmethod
-    def _regex_filter(self, regex_filter: "scout_compute_api_LogRegexFilterSeries") -> Any:
-        pass
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'cutoff_frequency': ConjureFieldDefinition('cutoffFrequency', scout_compute_api_DoubleConstant)
+        }
+
+    __slots__: List[str] = ['_cutoff_frequency']
+
+    def __init__(self, cutoff_frequency: "scout_compute_api_DoubleConstant") -> None:
+        self._cutoff_frequency = cutoff_frequency
+
+    @builtins.property
+    def cutoff_frequency(self) -> "scout_compute_api_DoubleConstant":
+        return self._cutoff_frequency
 
 
-scout_compute_api_LogValueFilterSeriesVisitor.__name__ = "LogValueFilterSeriesVisitor"
-scout_compute_api_LogValueFilterSeriesVisitor.__qualname__ = "LogValueFilterSeriesVisitor"
-scout_compute_api_LogValueFilterSeriesVisitor.__module__ = "nominal_api.scout_compute_api"
+scout_compute_api_LowPassConfiguration.__name__ = "LowPassConfiguration"
+scout_compute_api_LowPassConfiguration.__qualname__ = "LowPassConfiguration"
+scout_compute_api_LowPassConfiguration.__module__ = "nominal_api.scout_compute_api"
 
 
 class scout_compute_api_MaxSeries(ConjureBeanType):
@@ -33312,6 +33231,7 @@ class scout_compute_api_NumericSeries(ConjureUnionType):
     _channel: Optional["scout_compute_api_ChannelSeries"] = None
     _resample: Optional["scout_compute_api_NumericResampleSeries"] = None
     _rolling_operation: Optional["scout_compute_api_RollingOperationSeries"] = None
+    _signal_filter: Optional["scout_compute_api_SignalFilterSeries"] = None
     _sum: Optional["scout_compute_api_SumSeries"] = None
     _scale: Optional["scout_compute_api_ScaleSeries"] = None
     _time_difference: Optional["scout_compute_api_TimeDifferenceSeries"] = None
@@ -33344,6 +33264,7 @@ class scout_compute_api_NumericSeries(ConjureUnionType):
             'channel': ConjureFieldDefinition('channel', scout_compute_api_ChannelSeries),
             'resample': ConjureFieldDefinition('resample', scout_compute_api_NumericResampleSeries),
             'rolling_operation': ConjureFieldDefinition('rollingOperation', scout_compute_api_RollingOperationSeries),
+            'signal_filter': ConjureFieldDefinition('signalFilter', scout_compute_api_SignalFilterSeries),
             'sum': ConjureFieldDefinition('sum', scout_compute_api_SumSeries),
             'scale': ConjureFieldDefinition('scale', scout_compute_api_ScaleSeries),
             'time_difference': ConjureFieldDefinition('timeDifference', scout_compute_api_TimeDifferenceSeries),
@@ -33376,6 +33297,7 @@ class scout_compute_api_NumericSeries(ConjureUnionType):
             channel: Optional["scout_compute_api_ChannelSeries"] = None,
             resample: Optional["scout_compute_api_NumericResampleSeries"] = None,
             rolling_operation: Optional["scout_compute_api_RollingOperationSeries"] = None,
+            signal_filter: Optional["scout_compute_api_SignalFilterSeries"] = None,
             sum: Optional["scout_compute_api_SumSeries"] = None,
             scale: Optional["scout_compute_api_ScaleSeries"] = None,
             time_difference: Optional["scout_compute_api_TimeDifferenceSeries"] = None,
@@ -33391,7 +33313,7 @@ class scout_compute_api_NumericSeries(ConjureUnionType):
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (aggregate is not None) + (arithmetic is not None) + (bit_operation is not None) + (cumulative_sum is not None) + (derivative is not None) + (function is not None) + (integral is not None) + (max is not None) + (mean is not None) + (min is not None) + (offset is not None) + (product is not None) + (raw is not None) + (channel is not None) + (resample is not None) + (rolling_operation is not None) + (sum is not None) + (scale is not None) + (time_difference is not None) + (time_range_filter is not None) + (time_shift is not None) + (unary_arithmetic is not None) + (binary_arithmetic is not None) + (union is not None) + (unit_conversion is not None) + (value_difference is not None) + (filter_transformation is not None) + (threshold_filter is not None) != 1:
+            if (aggregate is not None) + (arithmetic is not None) + (bit_operation is not None) + (cumulative_sum is not None) + (derivative is not None) + (function is not None) + (integral is not None) + (max is not None) + (mean is not None) + (min is not None) + (offset is not None) + (product is not None) + (raw is not None) + (channel is not None) + (resample is not None) + (rolling_operation is not None) + (signal_filter is not None) + (sum is not None) + (scale is not None) + (time_difference is not None) + (time_range_filter is not None) + (time_shift is not None) + (unary_arithmetic is not None) + (binary_arithmetic is not None) + (union is not None) + (unit_conversion is not None) + (value_difference is not None) + (filter_transformation is not None) + (threshold_filter is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if aggregate is not None:
@@ -33442,6 +33364,9 @@ class scout_compute_api_NumericSeries(ConjureUnionType):
             if rolling_operation is not None:
                 self._rolling_operation = rolling_operation
                 self._type = 'rollingOperation'
+            if signal_filter is not None:
+                self._signal_filter = signal_filter
+                self._type = 'signalFilter'
             if sum is not None:
                 self._sum = sum
                 self._type = 'sum'
@@ -33559,6 +33484,11 @@ class scout_compute_api_NumericSeries(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._rolling_operation = rolling_operation
             self._type = 'rollingOperation'
+        elif type_of_union == 'signalFilter':
+            if signal_filter is None:
+                raise ValueError('a union value must not be None')
+            self._signal_filter = signal_filter
+            self._type = 'signalFilter'
         elif type_of_union == 'sum':
             if sum is None:
                 raise ValueError('a union value must not be None')
@@ -33684,6 +33614,10 @@ class scout_compute_api_NumericSeries(ConjureUnionType):
     def rolling_operation(self) -> Optional["scout_compute_api_RollingOperationSeries"]:
         return self._rolling_operation
 
+    @builtins.property
+    def signal_filter(self) -> Optional["scout_compute_api_SignalFilterSeries"]:
+        return self._signal_filter
+
     @builtins.property
     def sum(self) -> Optional["scout_compute_api_SumSeries"]:
         return self._sum
@@ -33767,6 +33701,8 @@ class scout_compute_api_NumericSeries(ConjureUnionType):
             return visitor._resample(self.resample)
         if self._type == 'rollingOperation' and self.rolling_operation is not None:
             return visitor._rolling_operation(self.rolling_operation)
+        if self._type == 'signalFilter' and self.signal_filter is not None:
+            return visitor._signal_filter(self.signal_filter)
         if self._type == 'sum' and self.sum is not None:
             return visitor._sum(self.sum)
         if self._type == 'scale' and self.scale is not None:
@@ -33864,6 +33800,10 @@ class scout_compute_api_NumericSeriesVisitor:
     def _rolling_operation(self, rolling_operation: "scout_compute_api_RollingOperationSeries") -> Any:
         pass
 
+    @abstractmethod
+    def _signal_filter(self, signal_filter: "scout_compute_api_SignalFilterSeries") -> Any:
+        pass
+
     @abstractmethod
     def _sum(self, sum: "scout_compute_api_SumSeries") -> Any:
         pass
@@ -36226,6 +36166,180 @@ scout_compute_api_SetNegativeValuesToZero.__qualname__ = "SetNegativeValuesToZer
 scout_compute_api_SetNegativeValuesToZero.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_SignalFilterConfiguration(ConjureUnionType):
+    _low_pass: Optional["scout_compute_api_LowPassConfiguration"] = None
+    _high_pass: Optional["scout_compute_api_HighPassConfiguration"] = None
+    _band_pass: Optional["scout_compute_api_BandPassConfiguration"] = None
+    _band_stop: Optional["scout_compute_api_BandStopConfiguration"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'low_pass': ConjureFieldDefinition('lowPass', scout_compute_api_LowPassConfiguration),
+            'high_pass': ConjureFieldDefinition('highPass', scout_compute_api_HighPassConfiguration),
+            'band_pass': ConjureFieldDefinition('bandPass', scout_compute_api_BandPassConfiguration),
+            'band_stop': ConjureFieldDefinition('bandStop', scout_compute_api_BandStopConfiguration)
+        }
+
+    def __init__(
+            self,
+            low_pass: Optional["scout_compute_api_LowPassConfiguration"] = None,
+            high_pass: Optional["scout_compute_api_HighPassConfiguration"] = None,
+            band_pass: Optional["scout_compute_api_BandPassConfiguration"] = None,
+            band_stop: Optional["scout_compute_api_BandStopConfiguration"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (low_pass is not None) + (high_pass is not None) + (band_pass is not None) + (band_stop is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if low_pass is not None:
+                self._low_pass = low_pass
+                self._type = 'lowPass'
+            if high_pass is not None:
+                self._high_pass = high_pass
+                self._type = 'highPass'
+            if band_pass is not None:
+                self._band_pass = band_pass
+                self._type = 'bandPass'
+            if band_stop is not None:
+                self._band_stop = band_stop
+                self._type = 'bandStop'
+
+        elif type_of_union == 'lowPass':
+            if low_pass is None:
+                raise ValueError('a union value must not be None')
+            self._low_pass = low_pass
+            self._type = 'lowPass'
+        elif type_of_union == 'highPass':
+            if high_pass is None:
+                raise ValueError('a union value must not be None')
+            self._high_pass = high_pass
+            self._type = 'highPass'
+        elif type_of_union == 'bandPass':
+            if band_pass is None:
+                raise ValueError('a union value must not be None')
+            self._band_pass = band_pass
+            self._type = 'bandPass'
+        elif type_of_union == 'bandStop':
+            if band_stop is None:
+                raise ValueError('a union value must not be None')
+            self._band_stop = band_stop
+            self._type = 'bandStop'
+
+    @builtins.property
+    def low_pass(self) -> Optional["scout_compute_api_LowPassConfiguration"]:
+        return self._low_pass
+
+    @builtins.property
+    def high_pass(self) -> Optional["scout_compute_api_HighPassConfiguration"]:
+        return self._high_pass
+
+    @builtins.property
+    def band_pass(self) -> Optional["scout_compute_api_BandPassConfiguration"]:
+        return self._band_pass
+
+    @builtins.property
+    def band_stop(self) -> Optional["scout_compute_api_BandStopConfiguration"]:
+        return self._band_stop
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_compute_api_SignalFilterConfigurationVisitor):
+            raise ValueError('{} is not an instance of scout_compute_api_SignalFilterConfigurationVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'lowPass' and self.low_pass is not None:
+            return visitor._low_pass(self.low_pass)
+        if self._type == 'highPass' and self.high_pass is not None:
+            return visitor._high_pass(self.high_pass)
+        if self._type == 'bandPass' and self.band_pass is not None:
+            return visitor._band_pass(self.band_pass)
+        if self._type == 'bandStop' and self.band_stop is not None:
+            return visitor._band_stop(self.band_stop)
+
+
+scout_compute_api_SignalFilterConfiguration.__name__ = "SignalFilterConfiguration"
+scout_compute_api_SignalFilterConfiguration.__qualname__ = "SignalFilterConfiguration"
+scout_compute_api_SignalFilterConfiguration.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_SignalFilterConfigurationVisitor:
+
+    @abstractmethod
+    def _low_pass(self, low_pass: "scout_compute_api_LowPassConfiguration") -> Any:
+        pass
+
+    @abstractmethod
+    def _high_pass(self, high_pass: "scout_compute_api_HighPassConfiguration") -> Any:
+        pass
+
+    @abstractmethod
+    def _band_pass(self, band_pass: "scout_compute_api_BandPassConfiguration") -> Any:
+        pass
+
+    @abstractmethod
+    def _band_stop(self, band_stop: "scout_compute_api_BandStopConfiguration") -> Any:
+        pass
+
+
+scout_compute_api_SignalFilterConfigurationVisitor.__name__ = "SignalFilterConfigurationVisitor"
+scout_compute_api_SignalFilterConfigurationVisitor.__qualname__ = "SignalFilterConfigurationVisitor"
+scout_compute_api_SignalFilterConfigurationVisitor.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_SignalFilterSeries(ConjureBeanType):
+    """
+    Applies IIR-based signal filtering to input series. Includes low-pass, high-pass, band-pass, and band-stop
+filters. Currently supports variable-order bidirectional Butterworth filters, with fixed-size padding based
+on SciPy output.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'input': ConjureFieldDefinition('input', scout_compute_api_NumericSeries),
+            'signal_filter_configuration': ConjureFieldDefinition('signalFilterConfiguration', scout_compute_api_SignalFilterConfiguration),
+            'order': ConjureFieldDefinition('order', scout_compute_api_IntegerConstant),
+            'sampling_frequency': ConjureFieldDefinition('samplingFrequency', OptionalTypeWrapper[scout_compute_api_DoubleConstant])
+        }
+
+    __slots__: List[str] = ['_input', '_signal_filter_configuration', '_order', '_sampling_frequency']
+
+    def __init__(self, input: "scout_compute_api_NumericSeries", order: "scout_compute_api_IntegerConstant", signal_filter_configuration: "scout_compute_api_SignalFilterConfiguration", sampling_frequency: Optional["scout_compute_api_DoubleConstant"] = None) -> None:
+        self._input = input
+        self._signal_filter_configuration = signal_filter_configuration
+        self._order = order
+        self._sampling_frequency = sampling_frequency
+
+    @builtins.property
+    def input(self) -> "scout_compute_api_NumericSeries":
+        return self._input
+
+    @builtins.property
+    def signal_filter_configuration(self) -> "scout_compute_api_SignalFilterConfiguration":
+        """
+        Filter type and cutoff frequencies.
+        """
+        return self._signal_filter_configuration
+
+    @builtins.property
+    def order(self) -> "scout_compute_api_IntegerConstant":
+        """
+        Order of filter. Must be a positive integer, and is effectively doubled for bidirectional filters.
+        """
+        return self._order
+
+    @builtins.property
+    def sampling_frequency(self) -> Optional["scout_compute_api_DoubleConstant"]:
+        """
+        The sampling frequency of the input series. Used to calculate normalized frequency for cutoff frequencies.
+        """
+        return self._sampling_frequency
+
+
+scout_compute_api_SignalFilterSeries.__name__ = "SignalFilterSeries"
+scout_compute_api_SignalFilterSeries.__qualname__ = "SignalFilterSeries"
+scout_compute_api_SignalFilterSeries.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_StabilityDetectionRanges(ConjureBeanType):
     """
     Outputs a set of ranges where the input series is stable. For each point, the min and max are calculated over 
@@ -40681,6 +40795,64 @@ scout_compute_resolved_api_ArithmeticSeriesNode.__qualname__ = "ArithmeticSeries
 scout_compute_resolved_api_ArithmeticSeriesNode.__module__ = "nominal_api.scout_compute_resolved_api"
 
 
+class scout_compute_resolved_api_BandPassConfiguration(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'low_passband_frequency': ConjureFieldDefinition('lowPassbandFrequency', float),
+            'high_passband_frequency': ConjureFieldDefinition('highPassbandFrequency', float)
+        }
+
+    __slots__: List[str] = ['_low_passband_frequency', '_high_passband_frequency']
+
+    def __init__(self, high_passband_frequency: float, low_passband_frequency: float) -> None:
+        self._low_passband_frequency = low_passband_frequency
+        self._high_passband_frequency = high_passband_frequency
+
+    @builtins.property
+    def low_passband_frequency(self) -> float:
+        return self._low_passband_frequency
+
+    @builtins.property
+    def high_passband_frequency(self) -> float:
+        return self._high_passband_frequency
+
+
+scout_compute_resolved_api_BandPassConfiguration.__name__ = "BandPassConfiguration"
+scout_compute_resolved_api_BandPassConfiguration.__qualname__ = "BandPassConfiguration"
+scout_compute_resolved_api_BandPassConfiguration.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
+class scout_compute_resolved_api_BandStopConfiguration(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'low_stopband_frequency': ConjureFieldDefinition('lowStopbandFrequency', float),
+            'high_stopband_frequency': ConjureFieldDefinition('highStopbandFrequency', float)
+        }
+
+    __slots__: List[str] = ['_low_stopband_frequency', '_high_stopband_frequency']
+
+    def __init__(self, high_stopband_frequency: float, low_stopband_frequency: float) -> None:
+        self._low_stopband_frequency = low_stopband_frequency
+        self._high_stopband_frequency = high_stopband_frequency
+
+    @builtins.property
+    def low_stopband_frequency(self) -> float:
+        return self._low_stopband_frequency
+
+    @builtins.property
+    def high_stopband_frequency(self) -> float:
+        return self._high_stopband_frequency
+
+
+scout_compute_resolved_api_BandStopConfiguration.__name__ = "BandStopConfiguration"
+scout_compute_resolved_api_BandStopConfiguration.__qualname__ = "BandStopConfiguration"
+scout_compute_resolved_api_BandStopConfiguration.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
 class scout_compute_resolved_api_BinaryArithmeticSeriesNode(ConjureBeanType):
 
     @builtins.classmethod
@@ -41644,6 +41816,29 @@ scout_compute_resolved_api_GeoNodeTemporalSummary.__qualname__ = "GeoNodeTempora
 scout_compute_resolved_api_GeoNodeTemporalSummary.__module__ = "nominal_api.scout_compute_resolved_api"
 
 
+class scout_compute_resolved_api_HighPassConfiguration(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'cutoff_frequency': ConjureFieldDefinition('cutoffFrequency', float)
+        }
+
+    __slots__: List[str] = ['_cutoff_frequency']
+
+    def __init__(self, cutoff_frequency: float) -> None:
+        self._cutoff_frequency = cutoff_frequency
+
+    @builtins.property
+    def cutoff_frequency(self) -> float:
+        return self._cutoff_frequency
+
+
+scout_compute_resolved_api_HighPassConfiguration.__name__ = "HighPassConfiguration"
+scout_compute_resolved_api_HighPassConfiguration.__qualname__ = "HighPassConfiguration"
+scout_compute_resolved_api_HighPassConfiguration.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
 class scout_compute_resolved_api_HistogramNode(ConjureUnionType):
     _numeric_histogram: Optional["scout_compute_resolved_api_NumericHistogramNode"] = None
     _enum_histogram: Optional["scout_compute_resolved_api_EnumHistogramNode"] = None
@@ -41899,6 +42094,29 @@ scout_compute_resolved_api_LatLongGeoNode.__qualname__ = "LatLongGeoNode"
 scout_compute_resolved_api_LatLongGeoNode.__module__ = "nominal_api.scout_compute_resolved_api"
 
 
+class scout_compute_resolved_api_LowPassConfiguration(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'cutoff_frequency': ConjureFieldDefinition('cutoffFrequency', float)
+        }
+
+    __slots__: List[str] = ['_cutoff_frequency']
+
+    def __init__(self, cutoff_frequency: float) -> None:
+        self._cutoff_frequency = cutoff_frequency
+
+    @builtins.property
+    def cutoff_frequency(self) -> float:
+        return self._cutoff_frequency
+
+
+scout_compute_resolved_api_LowPassConfiguration.__name__ = "LowPassConfiguration"
+scout_compute_resolved_api_LowPassConfiguration.__qualname__ = "LowPassConfiguration"
+scout_compute_resolved_api_LowPassConfiguration.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
 class scout_compute_resolved_api_MaxSeriesNode(ConjureBeanType):
 
     @builtins.classmethod
@@ -42267,6 +42485,7 @@ class scout_compute_resolved_api_NumericSeriesNode(ConjureUnionType):
     _resample: Optional["scout_compute_resolved_api_NumericResampleSeriesNode"] = None
     _rolling_operation: Optional["scout_compute_resolved_api_RollingOperationSeriesNode"] = None
     _aggregate: Optional["scout_compute_resolved_api_AggregateNumericSeriesNode"] = None
+    _signal_filter: Optional["scout_compute_resolved_api_SignalFilterSeriesNode"] = None
     _sum: Optional["scout_compute_resolved_api_SumSeriesNode"] = None
     _scale: Optional["scout_compute_resolved_api_ScaleSeriesNode"] = None
     _time_difference: Optional["scout_compute_resolved_api_TimeDifferenceSeriesNode"] = None
@@ -42296,6 +42515,7 @@ class scout_compute_resolved_api_NumericSeriesNode(ConjureUnionType):
             'resample': ConjureFieldDefinition('resample', scout_compute_resolved_api_NumericResampleSeriesNode),
             'rolling_operation': ConjureFieldDefinition('rollingOperation', scout_compute_resolved_api_RollingOperationSeriesNode),
             'aggregate': ConjureFieldDefinition('aggregate', scout_compute_resolved_api_AggregateNumericSeriesNode),
+            'signal_filter': ConjureFieldDefinition('signalFilter', scout_compute_resolved_api_SignalFilterSeriesNode),
             'sum': ConjureFieldDefinition('sum', scout_compute_resolved_api_SumSeriesNode),
             'scale': ConjureFieldDefinition('scale', scout_compute_resolved_api_ScaleSeriesNode),
             'time_difference': ConjureFieldDefinition('timeDifference', scout_compute_resolved_api_TimeDifferenceSeriesNode),
@@ -42325,6 +42545,7 @@ class scout_compute_resolved_api_NumericSeriesNode(ConjureUnionType):
             resample: Optional["scout_compute_resolved_api_NumericResampleSeriesNode"] = None,
             rolling_operation: Optional["scout_compute_resolved_api_RollingOperationSeriesNode"] = None,
             aggregate: Optional["scout_compute_resolved_api_AggregateNumericSeriesNode"] = None,
+            signal_filter: Optional["scout_compute_resolved_api_SignalFilterSeriesNode"] = None,
             sum: Optional["scout_compute_resolved_api_SumSeriesNode"] = None,
             scale: Optional["scout_compute_resolved_api_ScaleSeriesNode"] = None,
             time_difference: Optional["scout_compute_resolved_api_TimeDifferenceSeriesNode"] = None,
@@ -42339,7 +42560,7 @@ class scout_compute_resolved_api_NumericSeriesNode(ConjureUnionType):
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (arithmetic is not None) + (bit_operation is not None) + (cumulative_sum is not None) + (derivative is not None) + (integral is not None) + (max is not None) + (mean is not None) + (min is not None) + (offset is not None) + (product is not None) + (raw is not None) + (resample is not None) + (rolling_operation is not None) + (aggregate is not None) + (sum is not None) + (scale is not None) + (time_difference is not None) + (time_range_filter is not None) + (time_shift is not None) + (unary_arithmetic is not None) + (binary_arithmetic is not None) + (union is not None) + (unit_conversion is not None) + (value_difference is not None) + (filter_transformation is not None) != 1:
+            if (arithmetic is not None) + (bit_operation is not None) + (cumulative_sum is not None) + (derivative is not None) + (integral is not None) + (max is not None) + (mean is not None) + (min is not None) + (offset is not None) + (product is not None) + (raw is not None) + (resample is not None) + (rolling_operation is not None) + (aggregate is not None) + (signal_filter is not None) + (sum is not None) + (scale is not None) + (time_difference is not None) + (time_range_filter is not None) + (time_shift is not None) + (unary_arithmetic is not None) + (binary_arithmetic is not None) + (union is not None) + (unit_conversion is not None) + (value_difference is not None) + (filter_transformation is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if arithmetic is not None:
@@ -42384,6 +42605,9 @@ class scout_compute_resolved_api_NumericSeriesNode(ConjureUnionType):
             if aggregate is not None:
                 self._aggregate = aggregate
                 self._type = 'aggregate'
+            if signal_filter is not None:
+                self._signal_filter = signal_filter
+                self._type = 'signalFilter'
             if sum is not None:
                 self._sum = sum
                 self._type = 'sum'
@@ -42488,6 +42712,11 @@ class scout_compute_resolved_api_NumericSeriesNode(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._aggregate = aggregate
             self._type = 'aggregate'
+        elif type_of_union == 'signalFilter':
+            if signal_filter is None:
+                raise ValueError('a union value must not be None')
+            self._signal_filter = signal_filter
+            self._type = 'signalFilter'
         elif type_of_union == 'sum':
             if sum is None:
                 raise ValueError('a union value must not be None')
@@ -42600,6 +42829,10 @@ class scout_compute_resolved_api_NumericSeriesNode(ConjureUnionType):
     def aggregate(self) -> Optional["scout_compute_resolved_api_AggregateNumericSeriesNode"]:
         return self._aggregate
 
+    @builtins.property
+    def signal_filter(self) -> Optional["scout_compute_resolved_api_SignalFilterSeriesNode"]:
+        return self._signal_filter
+
     @builtins.property
     def sum(self) -> Optional["scout_compute_resolved_api_SumSeriesNode"]:
         return self._sum
@@ -42675,6 +42908,8 @@ class scout_compute_resolved_api_NumericSeriesNode(ConjureUnionType):
             return visitor._rolling_operation(self.rolling_operation)
         if self._type == 'aggregate' and self.aggregate is not None:
             return visitor._aggregate(self.aggregate)
+        if self._type == 'signalFilter' and self.signal_filter is not None:
+            return visitor._signal_filter(self.signal_filter)
         if self._type == 'sum' and self.sum is not None:
             return visitor._sum(self.sum)
         if self._type == 'scale' and self.scale is not None:
@@ -42762,6 +42997,10 @@ class scout_compute_resolved_api_NumericSeriesNodeVisitor:
     def _aggregate(self, aggregate: "scout_compute_resolved_api_AggregateNumericSeriesNode") -> Any:
         pass
 
+    @abstractmethod
+    def _signal_filter(self, signal_filter: "scout_compute_resolved_api_SignalFilterSeriesNode") -> Any:
+        pass
+
     @abstractmethod
     def _sum(self, sum: "scout_compute_resolved_api_SumSeriesNode") -> Any:
         pass
@@ -44047,6 +44286,181 @@ scout_compute_resolved_api_SeriesNodeVisitor.__qualname__ = "SeriesNodeVisitor"
 scout_compute_resolved_api_SeriesNodeVisitor.__module__ = "nominal_api.scout_compute_resolved_api"
 
 
+class scout_compute_resolved_api_SignalFilterConfiguration(ConjureUnionType):
+    _low_pass: Optional["scout_compute_resolved_api_LowPassConfiguration"] = None
+    _high_pass: Optional["scout_compute_resolved_api_HighPassConfiguration"] = None
+    _band_pass: Optional["scout_compute_resolved_api_BandPassConfiguration"] = None
+    _band_stop: Optional["scout_compute_resolved_api_BandStopConfiguration"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'low_pass': ConjureFieldDefinition('lowPass', scout_compute_resolved_api_LowPassConfiguration),
+            'high_pass': ConjureFieldDefinition('highPass', scout_compute_resolved_api_HighPassConfiguration),
+            'band_pass': ConjureFieldDefinition('bandPass', scout_compute_resolved_api_BandPassConfiguration),
+            'band_stop': ConjureFieldDefinition('bandStop', scout_compute_resolved_api_BandStopConfiguration)
+        }
+
+    def __init__(
+            self,
+            low_pass: Optional["scout_compute_resolved_api_LowPassConfiguration"] = None,
+            high_pass: Optional["scout_compute_resolved_api_HighPassConfiguration"] = None,
+            band_pass: Optional["scout_compute_resolved_api_BandPassConfiguration"] = None,
+            band_stop: Optional["scout_compute_resolved_api_BandStopConfiguration"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (low_pass is not None) + (high_pass is not None) + (band_pass is not None) + (band_stop is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if low_pass is not None:
+                self._low_pass = low_pass
+                self._type = 'lowPass'
+            if high_pass is not None:
+                self._high_pass = high_pass
+                self._type = 'highPass'
+            if band_pass is not None:
+                self._band_pass = band_pass
+                self._type = 'bandPass'
+            if band_stop is not None:
+                self._band_stop = band_stop
+                self._type = 'bandStop'
+
+        elif type_of_union == 'lowPass':
+            if low_pass is None:
+                raise ValueError('a union value must not be None')
+            self._low_pass = low_pass
+            self._type = 'lowPass'
+        elif type_of_union == 'highPass':
+            if high_pass is None:
+                raise ValueError('a union value must not be None')
+            self._high_pass = high_pass
+            self._type = 'highPass'
+        elif type_of_union == 'bandPass':
+            if band_pass is None:
+                raise ValueError('a union value must not be None')
+            self._band_pass = band_pass
+            self._type = 'bandPass'
+        elif type_of_union == 'bandStop':
+            if band_stop is None:
+                raise ValueError('a union value must not be None')
+            self._band_stop = band_stop
+            self._type = 'bandStop'
+
+    @builtins.property
+    def low_pass(self) -> Optional["scout_compute_resolved_api_LowPassConfiguration"]:
+        return self._low_pass
+
+    @builtins.property
+    def high_pass(self) -> Optional["scout_compute_resolved_api_HighPassConfiguration"]:
+        return self._high_pass
+
+    @builtins.property
+    def band_pass(self) -> Optional["scout_compute_resolved_api_BandPassConfiguration"]:
+        return self._band_pass
+
+    @builtins.property
+    def band_stop(self) -> Optional["scout_compute_resolved_api_BandStopConfiguration"]:
+        return self._band_stop
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_compute_resolved_api_SignalFilterConfigurationVisitor):
+            raise ValueError('{} is not an instance of scout_compute_resolved_api_SignalFilterConfigurationVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'lowPass' and self.low_pass is not None:
+            return visitor._low_pass(self.low_pass)
+        if self._type == 'highPass' and self.high_pass is not None:
+            return visitor._high_pass(self.high_pass)
+        if self._type == 'bandPass' and self.band_pass is not None:
+            return visitor._band_pass(self.band_pass)
+        if self._type == 'bandStop' and self.band_stop is not None:
+            return visitor._band_stop(self.band_stop)
+
+
+scout_compute_resolved_api_SignalFilterConfiguration.__name__ = "SignalFilterConfiguration"
+scout_compute_resolved_api_SignalFilterConfiguration.__qualname__ = "SignalFilterConfiguration"
+scout_compute_resolved_api_SignalFilterConfiguration.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
+class scout_compute_resolved_api_SignalFilterConfigurationVisitor:
+
+    @abstractmethod
+    def _low_pass(self, low_pass: "scout_compute_resolved_api_LowPassConfiguration") -> Any:
+        pass
+
+    @abstractmethod
+    def _high_pass(self, high_pass: "scout_compute_resolved_api_HighPassConfiguration") -> Any:
+        pass
+
+    @abstractmethod
+    def _band_pass(self, band_pass: "scout_compute_resolved_api_BandPassConfiguration") -> Any:
+        pass
+
+    @abstractmethod
+    def _band_stop(self, band_stop: "scout_compute_resolved_api_BandStopConfiguration") -> Any:
+        pass
+
+
+scout_compute_resolved_api_SignalFilterConfigurationVisitor.__name__ = "SignalFilterConfigurationVisitor"
+scout_compute_resolved_api_SignalFilterConfigurationVisitor.__qualname__ = "SignalFilterConfigurationVisitor"
+scout_compute_resolved_api_SignalFilterConfigurationVisitor.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
+class scout_compute_resolved_api_SignalFilterSeriesNode(ConjureBeanType):
+    """
+    Applies IIR-based signal filtering to input series. Includes low-pass, high-pass, band-pass, and band-stop
+filters. Currently supports variable-order bidirectional Butterworth filters, with fixed-size padding based
+on SciPy output.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'input': ConjureFieldDefinition('input', scout_compute_resolved_api_NumericSeriesNode),
+            'signal_filter_configuration': ConjureFieldDefinition('signalFilterConfiguration', scout_compute_resolved_api_SignalFilterConfiguration),
+            'order': ConjureFieldDefinition('order', int),
+            'sampling_frequency': ConjureFieldDefinition('samplingFrequency', OptionalTypeWrapper[float])
+        }
+
+    __slots__: List[str] = ['_input', '_signal_filter_configuration', '_order', '_sampling_frequency']
+
+    def __init__(self, input: "scout_compute_resolved_api_NumericSeriesNode", order: int, signal_filter_configuration: "scout_compute_resolved_api_SignalFilterConfiguration", sampling_frequency: Optional[float] = None) -> None:
+        self._input = input
+        self._signal_filter_configuration = signal_filter_configuration
+        self._order = order
+        self._sampling_frequency = sampling_frequency
+
+    @builtins.property
+    def input(self) -> "scout_compute_resolved_api_NumericSeriesNode":
+        return self._input
+
+    @builtins.property
+    def signal_filter_configuration(self) -> "scout_compute_resolved_api_SignalFilterConfiguration":
+        """
+        Configuration for the signal filter, including filter type, cutoff frequency, and order.
+        """
+        return self._signal_filter_configuration
+
+    @builtins.property
+    def order(self) -> int:
+        """
+        Order of filter. Must be a positive integer, and is effectively doubled for bidirectional filters.
+        """
+        return self._order
+
+    @builtins.property
+    def sampling_frequency(self) -> Optional[float]:
+        """
+        The sampling frequency of the input series. Used to calculate normalized frequency for cutoff frequencies.
+Defaults to number of points divided by timespan of series.
+        """
+        return self._sampling_frequency
+
+
+scout_compute_resolved_api_SignalFilterSeriesNode.__name__ = "SignalFilterSeriesNode"
+scout_compute_resolved_api_SignalFilterSeriesNode.__qualname__ = "SignalFilterSeriesNode"
+scout_compute_resolved_api_SignalFilterSeriesNode.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
 class scout_compute_resolved_api_StabilityDetectionRangesNode(ConjureBeanType):
 
     @builtins.classmethod
@@ -56803,29 +57217,6 @@ scout_run_api_DataSourceType.__qualname__ = "DataSourceType"
 scout_run_api_DataSourceType.__module__ = "nominal_api.scout_run_api"
 
 
-class scout_run_api_DeleteEventsFromRunRequest(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'events': ConjureFieldDefinition('events', List[event_EventRid])
-        }
-
-    __slots__: List[str] = ['_events']
-
-    def __init__(self, events: List[str]) -> None:
-        self._events = events
-
-    @builtins.property
-    def events(self) -> List[str]:
-        return self._events
-
-
-scout_run_api_DeleteEventsFromRunRequest.__name__ = "DeleteEventsFromRunRequest"
-scout_run_api_DeleteEventsFromRunRequest.__qualname__ = "DeleteEventsFromRunRequest"
-scout_run_api_DeleteEventsFromRunRequest.__module__ = "nominal_api.scout_run_api"
-
-
 class scout_run_api_Duration(ConjureBeanType):
 
     @builtins.classmethod
@@ -56861,35 +57252,6 @@ scout_run_api_Duration.__qualname__ = "Duration"
 scout_run_api_Duration.__module__ = "nominal_api.scout_run_api"
 
 
-class scout_run_api_GetEventsForRunPage(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'events': ConjureFieldDefinition('events', List[event_EventRid]),
-            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[scout_api_Token])
-        }
-
-    __slots__: List[str] = ['_events', '_next_page_token']
-
-    def __init__(self, events: List[str], next_page_token: Optional[str] = None) -> None:
-        self._events = events
-        self._next_page_token = next_page_token
-
-    @builtins.property
-    def events(self) -> List[str]:
-        return self._events
-
-    @builtins.property
-    def next_page_token(self) -> Optional[str]:
-        return self._next_page_token
-
-
-scout_run_api_GetEventsForRunPage.__name__ = "GetEventsForRunPage"
-scout_run_api_GetEventsForRunPage.__qualname__ = "GetEventsForRunPage"
-scout_run_api_GetEventsForRunPage.__module__ = "nominal_api.scout_run_api"
-
-
 class scout_run_api_GetRunByIdRequest(ConjureBeanType):
 
     @builtins.classmethod
@@ -57035,29 +57397,6 @@ scout_run_api_Property.__qualname__ = "Property"
 scout_run_api_Property.__module__ = "nominal_api.scout_run_api"
 
 
-class scout_run_api_PublishEventsToRunRequest(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'events': ConjureFieldDefinition('events', List[event_EventRid])
-        }
-
-    __slots__: List[str] = ['_events']
-
-    def __init__(self, events: List[str]) -> None:
-        self._events = events
-
-    @builtins.property
-    def events(self) -> List[str]:
-        return self._events
-
-
-scout_run_api_PublishEventsToRunRequest.__name__ = "PublishEventsToRunRequest"
-scout_run_api_PublishEventsToRunRequest.__qualname__ = "PublishEventsToRunRequest"
-scout_run_api_PublishEventsToRunRequest.__module__ = "nominal_api.scout_run_api"
-
-
 class scout_run_api_RefNameAndType(ConjureBeanType):
     """
     Scoped to the org-level, intended to help the frontend
@@ -62822,15 +63161,17 @@ class storage_datasource_api_CreateNominalDataSourceRequest(ConjureBeanType):
         return {
             'id': ConjureFieldDefinition('id', storage_datasource_api_NominalDataSourceId),
             'description': ConjureFieldDefinition('description', OptionalTypeWrapper[str]),
-            'granularity': ConjureFieldDefinition('granularity', OptionalTypeWrapper[api_Granularity])
+            'granularity': ConjureFieldDefinition('granularity', OptionalTypeWrapper[api_Granularity]),
+            'in_memory_streaming_enabled': ConjureFieldDefinition('inMemoryStreamingEnabled', OptionalTypeWrapper[bool])
         }
 
-    __slots__: List[str] = ['_id', '_description', '_granularity']
+    __slots__: List[str] = ['_id', '_description', '_granularity', '_in_memory_streaming_enabled']
 
-    def __init__(self, id: str, description: Optional[str] = None, granularity: Optional["api_Granularity"] = None) -> None:
+    def __init__(self, id: str, description: Optional[str] = None, granularity: Optional["api_Granularity"] = None, in_memory_streaming_enabled: Optional[bool] = None) -> None:
         self._id = id
         self._description = description
         self._granularity = granularity
+        self._in_memory_streaming_enabled = in_memory_streaming_enabled
 
     @builtins.property
     def id(self) -> str:
@@ -62851,6 +63192,10 @@ Defaults to nanosecond granularity.
         """
         return self._granularity
 
+    @builtins.property
+    def in_memory_streaming_enabled(self) -> Optional[bool]:
+        return self._in_memory_streaming_enabled
+
 
 storage_datasource_api_CreateNominalDataSourceRequest.__name__ = "CreateNominalDataSourceRequest"
 storage_datasource_api_CreateNominalDataSourceRequest.__qualname__ = "CreateNominalDataSourceRequest"
@@ -62869,17 +63214,19 @@ class storage_datasource_api_NominalDataSource(ConjureBeanType):
             'id': ConjureFieldDefinition('id', storage_datasource_api_NominalDataSourceId),
             'description': ConjureFieldDefinition('description', OptionalTypeWrapper[str]),
             'data_last_written_at': ConjureFieldDefinition('dataLastWrittenAt', OptionalTypeWrapper[str]),
-            'granularity': ConjureFieldDefinition('granularity', api_Granularity)
+            'granularity': ConjureFieldDefinition('granularity', api_Granularity),
+            'in_memory_streaming_enabled': ConjureFieldDefinition('inMemoryStreamingEnabled', OptionalTypeWrapper[bool])
         }
 
-    __slots__: List[str] = ['_rid', '_id', '_description', '_data_last_written_at', '_granularity']
+    __slots__: List[str] = ['_rid', '_id', '_description', '_data_last_written_at', '_granularity', '_in_memory_streaming_enabled']
 
-    def __init__(self, granularity: "api_Granularity", id: str, rid: str, data_last_written_at: Optional[str] = None, description: Optional[str] = None) -> None:
+    def __init__(self, granularity: "api_Granularity", id: str, rid: str, data_last_written_at: Optional[str] = None, description: Optional[str] = None, in_memory_streaming_enabled: Optional[bool] = None) -> None:
         self._rid = rid
         self._id = id
         self._description = description
         self._data_last_written_at = data_last_written_at
         self._granularity = granularity
+        self._in_memory_streaming_enabled = in_memory_streaming_enabled
 
     @builtins.property
     def rid(self) -> str:
@@ -62905,6 +63252,10 @@ Will be accurate to within 1 minute.
     def granularity(self) -> "api_Granularity":
         return self._granularity
 
+    @builtins.property
+    def in_memory_streaming_enabled(self) -> Optional[bool]:
+        return self._in_memory_streaming_enabled
+
 
 storage_datasource_api_NominalDataSource.__name__ = "NominalDataSource"
 storage_datasource_api_NominalDataSource.__qualname__ = "NominalDataSource"
@@ -62948,6 +63299,36 @@ class storage_datasource_api_NominalDataSourceService(Service):
         _decoder = ConjureDecoder()
         return _decoder.decode(_response.json(), storage_datasource_api_NominalDataSource, self._return_none_for_unknown_union_types)
 
+    def update(self, auth_header: str, request: "storage_datasource_api_UpdateNominalDataSourceRequest", rid: str) -> "storage_datasource_api_NominalDataSource":
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+            'rid': rid,
+        }
+
+        _json: Any = ConjureEncoder().default(request)
+
+        _path = '/storage/data-source/v1/{rid}'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'PUT',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        _decoder = ConjureDecoder()
+        return _decoder.decode(_response.json(), storage_datasource_api_NominalDataSource, self._return_none_for_unknown_union_types)
+
     def batch_get(self, auth_header: str, rids: List[str] = None) -> List["storage_datasource_api_NominalDataSource"]:
         """
         Retrieves the data sources for the given data source RIDs.
@@ -63021,6 +63402,29 @@ storage_datasource_api_NominalDataSourceService.__qualname__ = "NominalDataSourc
 storage_datasource_api_NominalDataSourceService.__module__ = "nominal_api.storage_datasource_api"
 
 
+class storage_datasource_api_UpdateNominalDataSourceRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'in_memory_streaming_enabled': ConjureFieldDefinition('inMemoryStreamingEnabled', bool)
+        }
+
+    __slots__: List[str] = ['_in_memory_streaming_enabled']
+
+    def __init__(self, in_memory_streaming_enabled: bool) -> None:
+        self._in_memory_streaming_enabled = in_memory_streaming_enabled
+
+    @builtins.property
+    def in_memory_streaming_enabled(self) -> bool:
+        return self._in_memory_streaming_enabled
+
+
+storage_datasource_api_UpdateNominalDataSourceRequest.__name__ = "UpdateNominalDataSourceRequest"
+storage_datasource_api_UpdateNominalDataSourceRequest.__qualname__ = "UpdateNominalDataSourceRequest"
+storage_datasource_api_UpdateNominalDataSourceRequest.__module__ = "nominal_api.storage_datasource_api"
+
+
 class storage_series_api_BatchCreateOrGetResponse(ConjureBeanType):
 
     @builtins.classmethod