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

nominal_api/_impl.py

@@ -59,6 +59,35 @@ api_Empty.__qualname__ = "Empty"
 api_Empty.__module__ = "nominal_api.api"
 
 
+class api_ErrorResult(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'error_type': ConjureFieldDefinition('errorType', api_ErrorType),
+            'message': ConjureFieldDefinition('message', str)
+        }
+
+    __slots__: List[str] = ['_error_type', '_message']
+
+    def __init__(self, error_type: str, message: str) -> None:
+        self._error_type = error_type
+        self._message = message
+
+    @builtins.property
+    def error_type(self) -> str:
+        return self._error_type
+
+    @builtins.property
+    def message(self) -> str:
+        return self._message
+
+
+api_ErrorResult.__name__ = "ErrorResult"
+api_ErrorResult.__qualname__ = "ErrorResult"
+api_ErrorResult.__module__ = "nominal_api.api"
+
+
 class api_Granularity(ConjureEnumType):
 
     PICOSECONDS = 'PICOSECONDS'
@@ -133,6 +162,140 @@ api_HandleVisitor.__qualname__ = "HandleVisitor"
 api_HandleVisitor.__module__ = "nominal_api.api"
 
 
+class api_InProgressResult(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+        }
+
+    __slots__: List[str] = []
+
+
+
+api_InProgressResult.__name__ = "InProgressResult"
+api_InProgressResult.__qualname__ = "InProgressResult"
+api_InProgressResult.__module__ = "nominal_api.api"
+
+
+class api_IngestStatus(ConjureEnumType):
+
+    SUCCEEDED = 'SUCCEEDED'
+    '''SUCCEEDED'''
+    FAILED = 'FAILED'
+    '''FAILED'''
+    IN_PROGRESS = 'IN_PROGRESS'
+    '''IN_PROGRESS'''
+    UNKNOWN = 'UNKNOWN'
+    '''UNKNOWN'''
+
+    def __reduce_ex__(self, proto):
+        return self.__class__, (self.name,)
+
+
+api_IngestStatus.__name__ = "IngestStatus"
+api_IngestStatus.__qualname__ = "IngestStatus"
+api_IngestStatus.__module__ = "nominal_api.api"
+
+
+class api_IngestStatusV2(ConjureUnionType):
+    _success: Optional["api_SuccessResult"] = None
+    _error: Optional["api_ErrorResult"] = None
+    _in_progress: Optional["api_InProgressResult"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'success': ConjureFieldDefinition('success', api_SuccessResult),
+            'error': ConjureFieldDefinition('error', api_ErrorResult),
+            'in_progress': ConjureFieldDefinition('inProgress', api_InProgressResult)
+        }
+
+    def __init__(
+            self,
+            success: Optional["api_SuccessResult"] = None,
+            error: Optional["api_ErrorResult"] = None,
+            in_progress: Optional["api_InProgressResult"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (success is not None) + (error is not None) + (in_progress is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if success is not None:
+                self._success = success
+                self._type = 'success'
+            if error is not None:
+                self._error = error
+                self._type = 'error'
+            if in_progress is not None:
+                self._in_progress = in_progress
+                self._type = 'inProgress'
+
+        elif type_of_union == 'success':
+            if success is None:
+                raise ValueError('a union value must not be None')
+            self._success = success
+            self._type = 'success'
+        elif type_of_union == 'error':
+            if error is None:
+                raise ValueError('a union value must not be None')
+            self._error = error
+            self._type = 'error'
+        elif type_of_union == 'inProgress':
+            if in_progress is None:
+                raise ValueError('a union value must not be None')
+            self._in_progress = in_progress
+            self._type = 'inProgress'
+
+    @builtins.property
+    def success(self) -> Optional["api_SuccessResult"]:
+        return self._success
+
+    @builtins.property
+    def error(self) -> Optional["api_ErrorResult"]:
+        return self._error
+
+    @builtins.property
+    def in_progress(self) -> Optional["api_InProgressResult"]:
+        return self._in_progress
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, api_IngestStatusV2Visitor):
+            raise ValueError('{} is not an instance of api_IngestStatusV2Visitor'.format(visitor.__class__.__name__))
+        if self._type == 'success' and self.success is not None:
+            return visitor._success(self.success)
+        if self._type == 'error' and self.error is not None:
+            return visitor._error(self.error)
+        if self._type == 'inProgress' and self.in_progress is not None:
+            return visitor._in_progress(self.in_progress)
+
+
+api_IngestStatusV2.__name__ = "IngestStatusV2"
+api_IngestStatusV2.__qualname__ = "IngestStatusV2"
+api_IngestStatusV2.__module__ = "nominal_api.api"
+
+
+class api_IngestStatusV2Visitor:
+
+    @abstractmethod
+    def _success(self, success: "api_SuccessResult") -> Any:
+        pass
+
+    @abstractmethod
+    def _error(self, error: "api_ErrorResult") -> Any:
+        pass
+
+    @abstractmethod
+    def _in_progress(self, in_progress: "api_InProgressResult") -> Any:
+        pass
+
+
+api_IngestStatusV2Visitor.__name__ = "IngestStatusV2Visitor"
+api_IngestStatusV2Visitor.__qualname__ = "IngestStatusV2Visitor"
+api_IngestStatusV2Visitor.__module__ = "nominal_api.api"
+
+
 class api_McapChannelLocator(ConjureUnionType):
     """Locator for a channel in an mcap file. Channel name is not guaranteed to be unique, so channel ID should
 be used for mcap files with duplicate channel names."""
@@ -306,6 +469,22 @@ api_SeriesDataType.__qualname__ = "SeriesDataType"
 api_SeriesDataType.__module__ = "nominal_api.api"
 
 
+class api_SuccessResult(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+        }
+
+    __slots__: List[str] = []
+
+
+
+api_SuccessResult.__name__ = "SuccessResult"
+api_SuccessResult.__qualname__ = "SuccessResult"
+api_SuccessResult.__module__ = "nominal_api.api"
+
+
 class api_TimeUnit(ConjureEnumType):
 
     DAYS = 'DAYS'
@@ -1710,7 +1889,7 @@ class authentication_api_SearchUsersRequest(ConjureBeanType):
         return {
             'query': ConjureFieldDefinition('query', authentication_api_SearchUsersQuery),
             'sort_by': ConjureFieldDefinition('sortBy', OptionalTypeWrapper[authentication_api_SortBy]),
-            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[scout_backend_Token]),
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token]),
             'page_size': ConjureFieldDefinition('pageSize', OptionalTypeWrapper[int])
         }
 
@@ -1756,7 +1935,7 @@ class authentication_api_SearchUsersResponseV2(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'results': ConjureFieldDefinition('results', List[authentication_api_UserV2]),
-            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[scout_backend_Token])
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token])
         }
 
     __slots__: List[str] = ['_results', '_next_page_token']
@@ -2599,7 +2778,7 @@ class authorization_ListApiKeyRequest(ConjureBeanType):
             'include_deleted': ConjureFieldDefinition('includeDeleted', OptionalTypeWrapper[bool]),
             'include_expired': ConjureFieldDefinition('includeExpired', OptionalTypeWrapper[bool]),
             'page_size': ConjureFieldDefinition('pageSize', OptionalTypeWrapper[int]),
-            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[scout_backend_Token])
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token])
         }
 
     __slots__: List[str] = ['_include_deleted', '_include_expired', '_page_size', '_next_page_token']
@@ -2647,7 +2826,7 @@ class authorization_ListApiKeyResponse(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'api_keys': ConjureFieldDefinition('apiKeys', List[authorization_ApiKey]),
-            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[scout_backend_Token])
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token])
         }
 
     __slots__: List[str] = ['_api_keys', '_next_page_token']
@@ -4166,7 +4345,7 @@ class datasource_api_SearchChannelsRequest(ConjureBeanType):
             'exact_match': ConjureFieldDefinition('exactMatch', List[str]),
             'data_sources': ConjureFieldDefinition('dataSources', List[api_rids_DataSourceRid]),
             'previously_selected_channels': ConjureFieldDefinition('previouslySelectedChannels', OptionalTypeWrapper[Dict[api_rids_DataSourceRid, List[api_Channel]]]),
-            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[datasource_Token]),
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token]),
             'page_size': ConjureFieldDefinition('pageSize', OptionalTypeWrapper[int])
         }
 
@@ -4227,7 +4406,7 @@ class datasource_api_SearchChannelsResponse(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'results': ConjureFieldDefinition('results', List[datasource_api_ChannelMetadata]),
-            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[datasource_Token])
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token])
         }
 
     __slots__: List[str] = ['_results', '_next_page_token']
@@ -5062,7 +5241,7 @@ class datasource_logset_api_SearchLogSetsRequest(ConjureBeanType):
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'token': ConjureFieldDefinition('token', OptionalTypeWrapper[datasource_logset_api_Token]),
+            'token': ConjureFieldDefinition('token', OptionalTypeWrapper[api_Token]),
             'page_size': ConjureFieldDefinition('pageSize', OptionalTypeWrapper[int])
         }
 
@@ -5095,7 +5274,7 @@ class datasource_logset_api_SearchLogSetsResponse(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'values': ConjureFieldDefinition('values', List[datasource_logset_api_LogSetMetadata]),
-            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[datasource_logset_api_Token])
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token])
         }
 
     __slots__: List[str] = ['_values', '_next_page_token']
@@ -5123,7 +5302,7 @@ class datasource_logset_api_SearchLogsRequest(ConjureBeanType):
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'token': ConjureFieldDefinition('token', OptionalTypeWrapper[datasource_logset_api_Token]),
+            'token': ConjureFieldDefinition('token', OptionalTypeWrapper[api_Token]),
             'page_size': ConjureFieldDefinition('pageSize', OptionalTypeWrapper[int])
         }
 
@@ -5156,7 +5335,7 @@ class datasource_logset_api_SearchLogsResponse(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'logs': ConjureFieldDefinition('logs', List[datasource_logset_api_Log]),
-            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[datasource_logset_api_Token])
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token])
         }
 
     __slots__: List[str] = ['_logs', '_next_page_token']
@@ -5765,7 +5944,7 @@ class event_SearchEventsRequest(ConjureBeanType):
         return {
             'sort': ConjureFieldDefinition('sort', event_SortOptions),
             'page_size': ConjureFieldDefinition('pageSize', int),
-            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[scout_api_Token]),
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token]),
             'query': ConjureFieldDefinition('query', event_SearchQuery),
             'archived_statuses': ConjureFieldDefinition('archivedStatuses', OptionalTypeWrapper[List[api_ArchivedStatus]])
         }
@@ -5817,7 +5996,7 @@ class event_SearchEventsResponse(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'results': ConjureFieldDefinition('results', List[event_Event]),
-            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[scout_api_Token])
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token])
         }
 
     __slots__: List[str] = ['_results', '_next_page_token']
@@ -6801,35 +6980,6 @@ ingest_api_EpochTimestamp.__qualname__ = "EpochTimestamp"
 ingest_api_EpochTimestamp.__module__ = "nominal_api.ingest_api"
 
 
-class ingest_api_ErrorResult(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'error_type': ConjureFieldDefinition('errorType', ingest_api_ErrorType),
-            'message': ConjureFieldDefinition('message', str)
-        }
-
-    __slots__: List[str] = ['_error_type', '_message']
-
-    def __init__(self, error_type: str, message: str) -> None:
-        self._error_type = error_type
-        self._message = message
-
-    @builtins.property
-    def error_type(self) -> str:
-        return self._error_type
-
-    @builtins.property
-    def message(self) -> str:
-        return self._message
-
-
-ingest_api_ErrorResult.__name__ = "ErrorResult"
-ingest_api_ErrorResult.__qualname__ = "ErrorResult"
-ingest_api_ErrorResult.__module__ = "nominal_api.ingest_api"
-
-
 class ingest_api_ExistingDatasetIngestDestination(ConjureBeanType):
 
     @builtins.classmethod
@@ -6876,22 +7026,6 @@ ingest_api_GcsIngestSource.__qualname__ = "GcsIngestSource"
 ingest_api_GcsIngestSource.__module__ = "nominal_api.ingest_api"
 
 
-class ingest_api_InProgressResult(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-        }
-
-    __slots__: List[str] = []
-
-
-
-ingest_api_InProgressResult.__name__ = "InProgressResult"
-ingest_api_InProgressResult.__qualname__ = "InProgressResult"
-ingest_api_InProgressResult.__module__ = "nominal_api.ingest_api"
-
-
 class ingest_api_IngestDataSource(ConjureUnionType):
     _existing_data_source: Optional[str] = None
     _new_data_source: Optional["ingest_api_DeprecatedNewDataSource"] = None
@@ -7379,13 +7513,13 @@ class ingest_api_IngestProgressV2(ConjureBeanType):
         return {
             'start_time': ConjureFieldDefinition('startTime', str),
             'end_time': ConjureFieldDefinition('endTime', OptionalTypeWrapper[str]),
-            'ingest_status': ConjureFieldDefinition('ingestStatus', ingest_api_IngestStatusV2),
+            'ingest_status': ConjureFieldDefinition('ingestStatus', api_IngestStatusV2),
             'incalculable': ConjureFieldDefinition('incalculable', OptionalTypeWrapper[bool])
         }
 
     __slots__: List[str] = ['_start_time', '_end_time', '_ingest_status', '_incalculable']
 
-    def __init__(self, ingest_status: "ingest_api_IngestStatusV2", start_time: str, end_time: Optional[str] = None, incalculable: Optional[bool] = None) -> None:
+    def __init__(self, ingest_status: "api_IngestStatusV2", start_time: str, end_time: Optional[str] = None, incalculable: Optional[bool] = None) -> None:
         self._start_time = start_time
         self._end_time = end_time
         self._ingest_status = ingest_status
@@ -7406,7 +7540,7 @@ class ingest_api_IngestProgressV2(ConjureBeanType):
         return self._end_time
 
     @builtins.property
-    def ingest_status(self) -> "ingest_api_IngestStatusV2":
+    def ingest_status(self) -> "api_IngestStatusV2":
         """
         Status of ingest, contains error if failed
         """
@@ -7957,104 +8091,6 @@ ingest_api_IngestStatus.__qualname__ = "IngestStatus"
 ingest_api_IngestStatus.__module__ = "nominal_api.ingest_api"
 
 
-class ingest_api_IngestStatusV2(ConjureUnionType):
-    _success: Optional["ingest_api_SuccessResult"] = None
-    _error: Optional["ingest_api_ErrorResult"] = None
-    _in_progress: Optional["ingest_api_InProgressResult"] = None
-
-    @builtins.classmethod
-    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'success': ConjureFieldDefinition('success', ingest_api_SuccessResult),
-            'error': ConjureFieldDefinition('error', ingest_api_ErrorResult),
-            'in_progress': ConjureFieldDefinition('inProgress', ingest_api_InProgressResult)
-        }
-
-    def __init__(
-            self,
-            success: Optional["ingest_api_SuccessResult"] = None,
-            error: Optional["ingest_api_ErrorResult"] = None,
-            in_progress: Optional["ingest_api_InProgressResult"] = None,
-            type_of_union: Optional[str] = None
-            ) -> None:
-        if type_of_union is None:
-            if (success is not None) + (error is not None) + (in_progress is not None) != 1:
-                raise ValueError('a union must contain a single member')
-
-            if success is not None:
-                self._success = success
-                self._type = 'success'
-            if error is not None:
-                self._error = error
-                self._type = 'error'
-            if in_progress is not None:
-                self._in_progress = in_progress
-                self._type = 'inProgress'
-
-        elif type_of_union == 'success':
-            if success is None:
-                raise ValueError('a union value must not be None')
-            self._success = success
-            self._type = 'success'
-        elif type_of_union == 'error':
-            if error is None:
-                raise ValueError('a union value must not be None')
-            self._error = error
-            self._type = 'error'
-        elif type_of_union == 'inProgress':
-            if in_progress is None:
-                raise ValueError('a union value must not be None')
-            self._in_progress = in_progress
-            self._type = 'inProgress'
-
-    @builtins.property
-    def success(self) -> Optional["ingest_api_SuccessResult"]:
-        return self._success
-
-    @builtins.property
-    def error(self) -> Optional["ingest_api_ErrorResult"]:
-        return self._error
-
-    @builtins.property
-    def in_progress(self) -> Optional["ingest_api_InProgressResult"]:
-        return self._in_progress
-
-    def accept(self, visitor) -> Any:
-        if not isinstance(visitor, ingest_api_IngestStatusV2Visitor):
-            raise ValueError('{} is not an instance of ingest_api_IngestStatusV2Visitor'.format(visitor.__class__.__name__))
-        if self._type == 'success' and self.success is not None:
-            return visitor._success(self.success)
-        if self._type == 'error' and self.error is not None:
-            return visitor._error(self.error)
-        if self._type == 'inProgress' and self.in_progress is not None:
-            return visitor._in_progress(self.in_progress)
-
-
-ingest_api_IngestStatusV2.__name__ = "IngestStatusV2"
-ingest_api_IngestStatusV2.__qualname__ = "IngestStatusV2"
-ingest_api_IngestStatusV2.__module__ = "nominal_api.ingest_api"
-
-
-class ingest_api_IngestStatusV2Visitor:
-
-    @abstractmethod
-    def _success(self, success: "ingest_api_SuccessResult") -> Any:
-        pass
-
-    @abstractmethod
-    def _error(self, error: "ingest_api_ErrorResult") -> Any:
-        pass
-
-    @abstractmethod
-    def _in_progress(self, in_progress: "ingest_api_InProgressResult") -> Any:
-        pass
-
-
-ingest_api_IngestStatusV2Visitor.__name__ = "IngestStatusV2Visitor"
-ingest_api_IngestStatusV2Visitor.__qualname__ = "IngestStatusV2Visitor"
-ingest_api_IngestStatusV2Visitor.__module__ = "nominal_api.ingest_api"
-
-
 class ingest_api_IngestVideoDestination(ConjureUnionType):
     _new_video: Optional["ingest_api_NewVideoIngestDestination"] = None
 
@@ -9287,22 +9323,6 @@ ingest_api_SkipRowsConfig.__qualname__ = "SkipRowsConfig"
 ingest_api_SkipRowsConfig.__module__ = "nominal_api.ingest_api"
 
 
-class ingest_api_SuccessResult(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-        }
-
-    __slots__: List[str] = []
-
-
-
-ingest_api_SuccessResult.__name__ = "SuccessResult"
-ingest_api_SuccessResult.__qualname__ = "SuccessResult"
-ingest_api_SuccessResult.__module__ = "nominal_api.ingest_api"
-
-
 class ingest_api_TimeOffsetSpec(ConjureUnionType):
     _nanos: Optional["scout_run_api_Duration"] = None
 
@@ -12436,7 +12456,7 @@ class scout_asset_api_SearchAssetChannelsRequest(ConjureBeanType):
         return {
             'search_text': ConjureFieldDefinition('searchText', str),
             'data_scope_name_filter': ConjureFieldDefinition('dataScopeNameFilter', OptionalTypeWrapper[List[scout_asset_api_DataScopeName]]),
-            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[scout_api_Token]),
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token]),
             'page_size': ConjureFieldDefinition('pageSize', OptionalTypeWrapper[int])
         }
 
@@ -12482,7 +12502,7 @@ class scout_asset_api_SearchAssetChannelsResponse(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'results': ConjureFieldDefinition('results', List[scout_asset_api_ChannelMetadata]),
-            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[scout_api_Token])
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token])
         }
 
     __slots__: List[str] = ['_results', '_next_page_token']
@@ -12694,7 +12714,7 @@ class scout_asset_api_SearchAssetsRequest(ConjureBeanType):
         return {
             'sort': ConjureFieldDefinition('sort', scout_asset_api_SortOptions),
             'page_size': ConjureFieldDefinition('pageSize', OptionalTypeWrapper[int]),
-            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[scout_api_Token]),
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token]),
             'query': ConjureFieldDefinition('query', scout_asset_api_SearchAssetsQuery),
             'archived_statuses': ConjureFieldDefinition('archivedStatuses', OptionalTypeWrapper[List[api_ArchivedStatus]])
         }
@@ -12746,7 +12766,7 @@ class scout_asset_api_SearchAssetsResponse(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'results': ConjureFieldDefinition('results', List[scout_asset_api_Asset]),
-            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[scout_api_Token])
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token])
         }
 
     __slots__: List[str] = ['_results', '_next_page_token']
@@ -12895,7 +12915,7 @@ class scout_asset_api_SearchTypesRequest(ConjureBeanType):
         return {
             'sort': ConjureFieldDefinition('sort', scout_asset_api_SortOptions),
             'page_size': ConjureFieldDefinition('pageSize', OptionalTypeWrapper[int]),
-            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[scout_api_Token]),
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token]),
             'query': ConjureFieldDefinition('query', scout_asset_api_SearchTypesQuery),
             'archived_statuses': ConjureFieldDefinition('archivedStatuses', OptionalTypeWrapper[List[api_ArchivedStatus]])
         }
@@ -12947,7 +12967,7 @@ class scout_asset_api_SearchTypesResponse(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'results': ConjureFieldDefinition('results', List[scout_asset_api_Type]),
-            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[scout_api_Token])
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token])
         }
 
     __slots__: List[str] = ['_results', '_next_page_token']
@@ -14159,7 +14179,7 @@ a file, primarily CSV.
         _decoder = ConjureDecoder()
         return _decoder.decode(_response.json(), scout_catalog_SearchDatasetsResponse, self._return_none_for_unknown_union_types)
 
-    def update_dataset_ingest_status_v2(self, auth_header: str, details: "scout_catalog_UpdateIngestStatusV2") -> "scout_catalog_IngestStatusV2":
+    def update_dataset_ingest_status_v2(self, auth_header: str, details: "scout_catalog_UpdateIngestStatusV2") -> "api_IngestStatusV2":
 
         _headers: Dict[str, Any] = {
             'Accept': 'application/json',
@@ -14186,7 +14206,7 @@ a file, primarily CSV.
             json=_json)
 
         _decoder = ConjureDecoder()
-        return _decoder.decode(_response.json(), scout_catalog_IngestStatusV2, self._return_none_for_unknown_union_types)
+        return _decoder.decode(_response.json(), api_IngestStatusV2, self._return_none_for_unknown_union_types)
 
     def get_ingest_progress_v2(self, auth_header: str, dataset_rid: str) -> "scout_catalog_IngestProgressV2":
 
@@ -14986,13 +15006,13 @@ class scout_catalog_DatasetFile(ConjureBeanType):
             'bounds': ConjureFieldDefinition('bounds', OptionalTypeWrapper[scout_catalog_Bounds]),
             'uploaded_at': ConjureFieldDefinition('uploadedAt', str),
             'ingested_at': ConjureFieldDefinition('ingestedAt', OptionalTypeWrapper[str]),
-            'ingest_status': ConjureFieldDefinition('ingestStatus', scout_catalog_IngestStatusV2),
+            'ingest_status': ConjureFieldDefinition('ingestStatus', api_IngestStatusV2),
             'timestamp_metadata': ConjureFieldDefinition('timestampMetadata', OptionalTypeWrapper[scout_catalog_TimestampMetadata])
         }
 
     __slots__: List[str] = ['_id', '_dataset_rid', '_name', '_handle', '_bounds', '_uploaded_at', '_ingested_at', '_ingest_status', '_timestamp_metadata']
 
-    def __init__(self, dataset_rid: str, handle: "scout_catalog_Handle", id: str, ingest_status: "scout_catalog_IngestStatusV2", name: str, uploaded_at: str, bounds: Optional["scout_catalog_Bounds"] = None, ingested_at: Optional[str] = None, timestamp_metadata: Optional["scout_catalog_TimestampMetadata"] = None) -> None:
+    def __init__(self, dataset_rid: str, handle: "scout_catalog_Handle", id: str, ingest_status: "api_IngestStatusV2", name: str, uploaded_at: str, bounds: Optional["scout_catalog_Bounds"] = None, ingested_at: Optional[str] = None, timestamp_metadata: Optional["scout_catalog_TimestampMetadata"] = None) -> None:
         self._id = id
         self._dataset_rid = dataset_rid
         self._name = name
@@ -15039,7 +15059,7 @@ ingested for any reason or is still being processed, then this value will be emp
         return self._ingested_at
 
     @builtins.property
-    def ingest_status(self) -> "scout_catalog_IngestStatusV2":
+    def ingest_status(self) -> "api_IngestStatusV2":
         return self._ingest_status
 
     @builtins.property
@@ -15085,7 +15105,7 @@ class scout_catalog_DatasetFilesPage(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'files': ConjureFieldDefinition('files', List[scout_catalog_DatasetFile]),
-            'next_page': ConjureFieldDefinition('nextPage', OptionalTypeWrapper[datasource_Token])
+            'next_page': ConjureFieldDefinition('nextPage', OptionalTypeWrapper[api_Token])
         }
 
     __slots__: List[str] = ['_files', '_next_page']
@@ -15252,7 +15272,7 @@ class scout_catalog_EnrichedDataset(ConjureBeanType):
             'ingest_date': ConjureFieldDefinition('ingestDate', str),
             'ingest_status': ConjureFieldDefinition('ingestStatus', OptionalTypeWrapper[scout_catalog_IngestStatus]),
             'origin_metadata': ConjureFieldDefinition('originMetadata', scout_catalog_DatasetOriginMetadata),
-            'last_ingest_status': ConjureFieldDefinition('lastIngestStatus', scout_catalog_IngestStatusV2),
+            'last_ingest_status': ConjureFieldDefinition('lastIngestStatus', api_IngestStatusV2),
             'retention_policy': ConjureFieldDefinition('retentionPolicy', scout_catalog_RetentionPolicy),
             'source': ConjureFieldDefinition('source', OptionalTypeWrapper[str]),
             'bounds': ConjureFieldDefinition('bounds', OptionalTypeWrapper[scout_catalog_Bounds]),
@@ -15264,7 +15284,7 @@ class scout_catalog_EnrichedDataset(ConjureBeanType):
 
     __slots__: List[str] = ['_rid', '_uuid', '_name', '_description', '_display_name', '_metadata', '_handle', '_ingest_date', '_ingest_status', '_origin_metadata', '_last_ingest_status', '_retention_policy', '_source', '_bounds', '_timestamp_type', '_labels', '_properties', '_granularity']
 
-    def __init__(self, display_name: str, granularity: "api_Granularity", ingest_date: str, labels: List[str], last_ingest_status: "scout_catalog_IngestStatusV2", name: str, origin_metadata: "scout_catalog_DatasetOriginMetadata", properties: Dict[str, str], retention_policy: "scout_catalog_RetentionPolicy", rid: str, timestamp_type: "scout_catalog_WeakTimestampType", uuid: str, bounds: Optional["scout_catalog_Bounds"] = None, description: Optional[str] = None, handle: Optional["scout_catalog_Handle"] = None, ingest_status: Optional["scout_catalog_IngestStatus"] = None, metadata: Optional[Dict[str, str]] = None, source: Optional[str] = None) -> None:
+    def __init__(self, display_name: str, granularity: "api_Granularity", ingest_date: str, labels: List[str], last_ingest_status: "api_IngestStatusV2", name: str, origin_metadata: "scout_catalog_DatasetOriginMetadata", properties: Dict[str, str], retention_policy: "scout_catalog_RetentionPolicy", rid: str, timestamp_type: "scout_catalog_WeakTimestampType", uuid: str, bounds: Optional["scout_catalog_Bounds"] = None, description: Optional[str] = None, handle: Optional["scout_catalog_Handle"] = None, ingest_status: Optional["scout_catalog_IngestStatus"] = None, metadata: Optional[Dict[str, str]] = None, source: Optional[str] = None) -> None:
         self._rid = rid
         self._uuid = uuid
         self._name = name
@@ -15325,7 +15345,7 @@ class scout_catalog_EnrichedDataset(ConjureBeanType):
         return self._origin_metadata
 
     @builtins.property
-    def last_ingest_status(self) -> "scout_catalog_IngestStatusV2":
+    def last_ingest_status(self) -> "api_IngestStatusV2":
         return self._last_ingest_status
 
     @builtins.property
@@ -15385,35 +15405,6 @@ scout_catalog_EpochTimestamp.__qualname__ = "EpochTimestamp"
 scout_catalog_EpochTimestamp.__module__ = "nominal_api.scout_catalog"
 
 
-class scout_catalog_ErrorResult(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'error_type': ConjureFieldDefinition('errorType', scout_catalog_ErrorType),
-            'message': ConjureFieldDefinition('message', str)
-        }
-
-    __slots__: List[str] = ['_error_type', '_message']
-
-    def __init__(self, error_type: str, message: str) -> None:
-        self._error_type = error_type
-        self._message = message
-
-    @builtins.property
-    def error_type(self) -> str:
-        return self._error_type
-
-    @builtins.property
-    def message(self) -> str:
-        return self._message
-
-
-scout_catalog_ErrorResult.__name__ = "ErrorResult"
-scout_catalog_ErrorResult.__qualname__ = "ErrorResult"
-scout_catalog_ErrorResult.__module__ = "nominal_api.scout_catalog"
-
-
 class scout_catalog_GetChannelsForDatasetsRequest(ConjureBeanType):
 
     @builtins.classmethod
@@ -15691,22 +15682,6 @@ scout_catalog_HandleVisitor.__qualname__ = "HandleVisitor"
 scout_catalog_HandleVisitor.__module__ = "nominal_api.scout_catalog"
 
 
-class scout_catalog_InProgressResult(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-        }
-
-    __slots__: List[str] = []
-
-
-
-scout_catalog_InProgressResult.__name__ = "InProgressResult"
-scout_catalog_InProgressResult.__qualname__ = "InProgressResult"
-scout_catalog_InProgressResult.__module__ = "nominal_api.scout_catalog"
-
-
 class scout_catalog_IngestProgressV2(ConjureBeanType):
 
     @builtins.classmethod
@@ -15714,13 +15689,13 @@ class scout_catalog_IngestProgressV2(ConjureBeanType):
         return {
             'start_time': ConjureFieldDefinition('startTime', str),
             'end_time': ConjureFieldDefinition('endTime', OptionalTypeWrapper[str]),
-            'ingest_status': ConjureFieldDefinition('ingestStatus', scout_catalog_IngestStatusV2),
+            'ingest_status': ConjureFieldDefinition('ingestStatus', api_IngestStatusV2),
             'incalculable': ConjureFieldDefinition('incalculable', OptionalTypeWrapper[bool])
         }
 
     __slots__: List[str] = ['_start_time', '_end_time', '_ingest_status', '_incalculable']
 
-    def __init__(self, ingest_status: "scout_catalog_IngestStatusV2", start_time: str, end_time: Optional[str] = None, incalculable: Optional[bool] = None) -> None:
+    def __init__(self, ingest_status: "api_IngestStatusV2", start_time: str, end_time: Optional[str] = None, incalculable: Optional[bool] = None) -> None:
         self._start_time = start_time
         self._end_time = end_time
         self._ingest_status = ingest_status
@@ -15741,7 +15716,7 @@ class scout_catalog_IngestProgressV2(ConjureBeanType):
         return self._end_time
 
     @builtins.property
-    def ingest_status(self) -> "scout_catalog_IngestStatusV2":
+    def ingest_status(self) -> "api_IngestStatusV2":
         """
         Status of ingest, contains error if failed
         """
@@ -15780,104 +15755,6 @@ scout_catalog_IngestStatus.__qualname__ = "IngestStatus"
 scout_catalog_IngestStatus.__module__ = "nominal_api.scout_catalog"
 
 
-class scout_catalog_IngestStatusV2(ConjureUnionType):
-    _success: Optional["scout_catalog_SuccessResult"] = None
-    _error: Optional["scout_catalog_ErrorResult"] = None
-    _in_progress: Optional["scout_catalog_InProgressResult"] = None
-
-    @builtins.classmethod
-    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'success': ConjureFieldDefinition('success', scout_catalog_SuccessResult),
-            'error': ConjureFieldDefinition('error', scout_catalog_ErrorResult),
-            'in_progress': ConjureFieldDefinition('inProgress', scout_catalog_InProgressResult)
-        }
-
-    def __init__(
-            self,
-            success: Optional["scout_catalog_SuccessResult"] = None,
-            error: Optional["scout_catalog_ErrorResult"] = None,
-            in_progress: Optional["scout_catalog_InProgressResult"] = None,
-            type_of_union: Optional[str] = None
-            ) -> None:
-        if type_of_union is None:
-            if (success is not None) + (error is not None) + (in_progress is not None) != 1:
-                raise ValueError('a union must contain a single member')
-
-            if success is not None:
-                self._success = success
-                self._type = 'success'
-            if error is not None:
-                self._error = error
-                self._type = 'error'
-            if in_progress is not None:
-                self._in_progress = in_progress
-                self._type = 'inProgress'
-
-        elif type_of_union == 'success':
-            if success is None:
-                raise ValueError('a union value must not be None')
-            self._success = success
-            self._type = 'success'
-        elif type_of_union == 'error':
-            if error is None:
-                raise ValueError('a union value must not be None')
-            self._error = error
-            self._type = 'error'
-        elif type_of_union == 'inProgress':
-            if in_progress is None:
-                raise ValueError('a union value must not be None')
-            self._in_progress = in_progress
-            self._type = 'inProgress'
-
-    @builtins.property
-    def success(self) -> Optional["scout_catalog_SuccessResult"]:
-        return self._success
-
-    @builtins.property
-    def error(self) -> Optional["scout_catalog_ErrorResult"]:
-        return self._error
-
-    @builtins.property
-    def in_progress(self) -> Optional["scout_catalog_InProgressResult"]:
-        return self._in_progress
-
-    def accept(self, visitor) -> Any:
-        if not isinstance(visitor, scout_catalog_IngestStatusV2Visitor):
-            raise ValueError('{} is not an instance of scout_catalog_IngestStatusV2Visitor'.format(visitor.__class__.__name__))
-        if self._type == 'success' and self.success is not None:
-            return visitor._success(self.success)
-        if self._type == 'error' and self.error is not None:
-            return visitor._error(self.error)
-        if self._type == 'inProgress' and self.in_progress is not None:
-            return visitor._in_progress(self.in_progress)
-
-
-scout_catalog_IngestStatusV2.__name__ = "IngestStatusV2"
-scout_catalog_IngestStatusV2.__qualname__ = "IngestStatusV2"
-scout_catalog_IngestStatusV2.__module__ = "nominal_api.scout_catalog"
-
-
-class scout_catalog_IngestStatusV2Visitor:
-
-    @abstractmethod
-    def _success(self, success: "scout_catalog_SuccessResult") -> Any:
-        pass
-
-    @abstractmethod
-    def _error(self, error: "scout_catalog_ErrorResult") -> Any:
-        pass
-
-    @abstractmethod
-    def _in_progress(self, in_progress: "scout_catalog_InProgressResult") -> Any:
-        pass
-
-
-scout_catalog_IngestStatusV2Visitor.__name__ = "IngestStatusV2Visitor"
-scout_catalog_IngestStatusV2Visitor.__qualname__ = "IngestStatusV2Visitor"
-scout_catalog_IngestStatusV2Visitor.__module__ = "nominal_api.scout_catalog"
-
-
 class scout_catalog_Iso8601Timestamp(ConjureBeanType):
 
     @builtins.classmethod
@@ -15928,16 +15805,16 @@ class scout_catalog_MarkFileIngestError(ConjureBeanType):
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'error_result': ConjureFieldDefinition('errorResult', scout_catalog_ErrorResult)
+            'error_result': ConjureFieldDefinition('errorResult', api_ErrorResult)
         }
 
     __slots__: List[str] = ['_error_result']
 
-    def __init__(self, error_result: "scout_catalog_ErrorResult") -> None:
+    def __init__(self, error_result: "api_ErrorResult") -> None:
         self._error_result = error_result
 
     @builtins.property
-    def error_result(self) -> "scout_catalog_ErrorResult":
+    def error_result(self) -> "api_ErrorResult":
         return self._error_result
 
 
@@ -16423,7 +16300,7 @@ class scout_catalog_SearchDatasetsRequest(ConjureBeanType):
         return {
             'query': ConjureFieldDefinition('query', scout_catalog_SearchDatasetsQuery),
             'page_size': ConjureFieldDefinition('pageSize', OptionalTypeWrapper[int]),
-            'token': ConjureFieldDefinition('token', OptionalTypeWrapper[datasource_Token]),
+            'token': ConjureFieldDefinition('token', OptionalTypeWrapper[api_Token]),
             'sort_options': ConjureFieldDefinition('sortOptions', scout_catalog_SortOptions)
         }
 
@@ -16466,7 +16343,7 @@ class scout_catalog_SearchDatasetsResponse(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'results': ConjureFieldDefinition('results', List[scout_catalog_EnrichedDataset]),
-            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[datasource_Token])
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token])
         }
 
     __slots__: List[str] = ['_results', '_next_page_token']
@@ -16616,22 +16493,6 @@ scout_catalog_SortOptions.__qualname__ = "SortOptions"
 scout_catalog_SortOptions.__module__ = "nominal_api.scout_catalog"
 
 
-class scout_catalog_SuccessResult(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-        }
-
-    __slots__: List[str] = []
-
-
-
-scout_catalog_SuccessResult.__name__ = "SuccessResult"
-scout_catalog_SuccessResult.__qualname__ = "SuccessResult"
-scout_catalog_SuccessResult.__module__ = "nominal_api.scout_catalog"
-
-
 class scout_catalog_TimestampMetadata(ConjureBeanType):
 
     @builtins.classmethod
@@ -16862,18 +16723,18 @@ class scout_catalog_UpdateIngestStatusV2(ConjureBeanType):
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'status': ConjureFieldDefinition('status', scout_catalog_IngestStatusV2),
+            'status': ConjureFieldDefinition('status', api_IngestStatusV2),
             'dataset_uuid': ConjureFieldDefinition('datasetUuid', str)
         }
 
     __slots__: List[str] = ['_status', '_dataset_uuid']
 
-    def __init__(self, dataset_uuid: str, status: "scout_catalog_IngestStatusV2") -> None:
+    def __init__(self, dataset_uuid: str, status: "api_IngestStatusV2") -> None:
         self._status = status
         self._dataset_uuid = dataset_uuid
 
     @builtins.property
-    def status(self) -> "scout_catalog_IngestStatusV2":
+    def status(self) -> "api_IngestStatusV2":
         return self._status
 
     @builtins.property
@@ -22143,7 +22004,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 +23409,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),
@@ -24446,7 +24307,7 @@ class scout_checks_api_SearchChecklistsRequest(ConjureBeanType):
         return {
             'query': ConjureFieldDefinition('query', scout_checks_api_ChecklistSearchQuery),
             'sort_by': ConjureFieldDefinition('sortBy', OptionalTypeWrapper[scout_checks_api_SortOptions]),
-            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[scout_api_Token]),
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token]),
             'page_size': ConjureFieldDefinition('pageSize', OptionalTypeWrapper[int]),
             'archived_statuses': ConjureFieldDefinition('archivedStatuses', OptionalTypeWrapper[List[api_ArchivedStatus]])
         }
@@ -25550,7 +25411,7 @@ class scout_checks_api_VersionedChecklistPage(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'values': ConjureFieldDefinition('values', List[scout_checks_api_VersionedChecklist]),
-            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[scout_api_Token])
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token])
         }
 
     __slots__: List[str] = ['_values', '_next_page_token']
@@ -26796,19 +26657,19 @@ class scout_comparisonnotebook_api_SupplementalComparisonWorkbookContext(Conjure
     """This is used to allow variables to specify additional context that does not fit well into the general shape of
 a compute node. For example, a range aggregation variable represents a bulk computation across several inputs,
 whose context is specified here instead."""
-    _none: Optional["scout_rids_api_Empty"] = None
+    _none: Optional["api_Empty"] = None
     _range_aggregation: Optional["scout_comparisonnotebook_api_RangeAggregationContext"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'none': ConjureFieldDefinition('none', scout_rids_api_Empty),
+            'none': ConjureFieldDefinition('none', api_Empty),
             'range_aggregation': ConjureFieldDefinition('rangeAggregation', scout_comparisonnotebook_api_RangeAggregationContext)
         }
 
     def __init__(
             self,
-            none: Optional["scout_rids_api_Empty"] = None,
+            none: Optional["api_Empty"] = None,
             range_aggregation: Optional["scout_comparisonnotebook_api_RangeAggregationContext"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
@@ -26835,7 +26696,7 @@ whose context is specified here instead."""
             self._type = 'rangeAggregation'
 
     @builtins.property
-    def none(self) -> Optional["scout_rids_api_Empty"]:
+    def none(self) -> Optional["api_Empty"]:
         return self._none
 
     @builtins.property
@@ -26859,7 +26720,7 @@ scout_comparisonnotebook_api_SupplementalComparisonWorkbookContext.__module__ =
 class scout_comparisonnotebook_api_SupplementalComparisonWorkbookContextVisitor:
 
     @abstractmethod
-    def _none(self, none: "scout_rids_api_Empty") -> Any:
+    def _none(self, none: "api_Empty") -> Any:
         pass
 
     @abstractmethod
@@ -27686,7 +27547,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 +29930,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
 
@@ -30079,6 +29940,136 @@ scout_compute_api_DataSourceChannel.__qualname__ = "DataSourceChannel"
 scout_compute_api_DataSourceChannel.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_DecimateStrategy(ConjureUnionType):
+    _resolution: Optional["scout_compute_api_DecimateWithResolution"] = None
+    _buckets: Optional["scout_compute_api_DecimateWithBuckets"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'resolution': ConjureFieldDefinition('resolution', scout_compute_api_DecimateWithResolution),
+            'buckets': ConjureFieldDefinition('buckets', scout_compute_api_DecimateWithBuckets)
+        }
+
+    def __init__(
+            self,
+            resolution: Optional["scout_compute_api_DecimateWithResolution"] = None,
+            buckets: Optional["scout_compute_api_DecimateWithBuckets"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (resolution is not None) + (buckets is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if resolution is not None:
+                self._resolution = resolution
+                self._type = 'resolution'
+            if buckets is not None:
+                self._buckets = buckets
+                self._type = 'buckets'
+
+        elif type_of_union == 'resolution':
+            if resolution is None:
+                raise ValueError('a union value must not be None')
+            self._resolution = resolution
+            self._type = 'resolution'
+        elif type_of_union == 'buckets':
+            if buckets is None:
+                raise ValueError('a union value must not be None')
+            self._buckets = buckets
+            self._type = 'buckets'
+
+    @builtins.property
+    def resolution(self) -> Optional["scout_compute_api_DecimateWithResolution"]:
+        return self._resolution
+
+    @builtins.property
+    def buckets(self) -> Optional["scout_compute_api_DecimateWithBuckets"]:
+        return self._buckets
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_compute_api_DecimateStrategyVisitor):
+            raise ValueError('{} is not an instance of scout_compute_api_DecimateStrategyVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'resolution' and self.resolution is not None:
+            return visitor._resolution(self.resolution)
+        if self._type == 'buckets' and self.buckets is not None:
+            return visitor._buckets(self.buckets)
+
+
+scout_compute_api_DecimateStrategy.__name__ = "DecimateStrategy"
+scout_compute_api_DecimateStrategy.__qualname__ = "DecimateStrategy"
+scout_compute_api_DecimateStrategy.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_DecimateStrategyVisitor:
+
+    @abstractmethod
+    def _resolution(self, resolution: "scout_compute_api_DecimateWithResolution") -> Any:
+        pass
+
+    @abstractmethod
+    def _buckets(self, buckets: "scout_compute_api_DecimateWithBuckets") -> Any:
+        pass
+
+
+scout_compute_api_DecimateStrategyVisitor.__name__ = "DecimateStrategyVisitor"
+scout_compute_api_DecimateStrategyVisitor.__qualname__ = "DecimateStrategyVisitor"
+scout_compute_api_DecimateStrategyVisitor.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_DecimateWithBuckets(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'buckets': ConjureFieldDefinition('buckets', int)
+        }
+
+    __slots__: List[str] = ['_buckets']
+
+    def __init__(self, buckets: int) -> None:
+        self._buckets = buckets
+
+    @builtins.property
+    def buckets(self) -> int:
+        """
+        Number of points to generate in the output series.
+        """
+        return self._buckets
+
+
+scout_compute_api_DecimateWithBuckets.__name__ = "DecimateWithBuckets"
+scout_compute_api_DecimateWithBuckets.__qualname__ = "DecimateWithBuckets"
+scout_compute_api_DecimateWithBuckets.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_DecimateWithResolution(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'resolution': ConjureFieldDefinition('resolution', int)
+        }
+
+    __slots__: List[str] = ['_resolution']
+
+    def __init__(self, resolution: int) -> None:
+        self._resolution = resolution
+
+    @builtins.property
+    def resolution(self) -> int:
+        """
+        Resolution of the output series specifying time interval between decimated points.
+Picoseconds for picosecond-granularity dataset, nanoseconds otherwise.
+        """
+        return self._resolution
+
+
+scout_compute_api_DecimateWithResolution.__name__ = "DecimateWithResolution"
+scout_compute_api_DecimateWithResolution.__qualname__ = "DecimateWithResolution"
+scout_compute_api_DecimateWithResolution.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_DerivativeSeries(ConjureBeanType):
     """
     Calculates the rate of change between subsequent points.
@@ -30277,22 +30268,6 @@ scout_compute_api_DurationConstantVisitor.__qualname__ = "DurationConstantVisito
 scout_compute_api_DurationConstantVisitor.__module__ = "nominal_api.scout_compute_api"
 
 
-class scout_compute_api_Empty(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-        }
-
-    __slots__: List[str] = []
-
-
-
-scout_compute_api_Empty.__name__ = "Empty"
-scout_compute_api_Empty.__qualname__ = "Empty"
-scout_compute_api_Empty.__module__ = "nominal_api.scout_compute_api"
-
-
 class scout_compute_api_EnumAggregationFunction(ConjureEnumType):
 
     MIN = 'MIN'
@@ -32153,30 +32128,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 +32276,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 +32304,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 +32337,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 +32357,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._value_filter = value_filter
-            self._type = 'valueFilter'
+            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._time_shift = time_shift
+            self._type = 'timeShift'
 
     @builtins.property
     def raw(self) -> Optional["scout_compute_api_Reference"]:
@@ -32344,17 +32381,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 +32400,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 +32424,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 +32441,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 +32551,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
@@ -34541,6 +34457,95 @@ scout_compute_api_OutputRangeStartVisitor.__qualname__ = "OutputRangeStartVisito
 scout_compute_api_OutputRangeStartVisitor.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_PageInfo(ConjureBeanType):
+    """
+    Specification of a page for a series. Returns raw undecimated points beginning nearest to the given page
+token timestamp, advancing pageSize points in the time direction specified by the sign of the page size.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'page_token': ConjureFieldDefinition('pageToken', api_Timestamp),
+            'page_size': ConjureFieldDefinition('pageSize', int)
+        }
+
+    __slots__: List[str] = ['_page_token', '_page_size']
+
+    def __init__(self, page_size: int, page_token: "api_Timestamp") -> None:
+        self._page_token = page_token
+        self._page_size = page_size
+
+    @builtins.property
+    def page_token(self) -> "api_Timestamp":
+        return self._page_token
+
+    @builtins.property
+    def page_size(self) -> int:
+        return self._page_size
+
+
+scout_compute_api_PageInfo.__name__ = "PageInfo"
+scout_compute_api_PageInfo.__qualname__ = "PageInfo"
+scout_compute_api_PageInfo.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_PageStrategy(ConjureUnionType):
+    _page_info: Optional["scout_compute_api_PageInfo"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'page_info': ConjureFieldDefinition('pageInfo', scout_compute_api_PageInfo)
+        }
+
+    def __init__(
+            self,
+            page_info: Optional["scout_compute_api_PageInfo"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (page_info is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if page_info is not None:
+                self._page_info = page_info
+                self._type = 'pageInfo'
+
+        elif type_of_union == 'pageInfo':
+            if page_info is None:
+                raise ValueError('a union value must not be None')
+            self._page_info = page_info
+            self._type = 'pageInfo'
+
+    @builtins.property
+    def page_info(self) -> Optional["scout_compute_api_PageInfo"]:
+        return self._page_info
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_compute_api_PageStrategyVisitor):
+            raise ValueError('{} is not an instance of scout_compute_api_PageStrategyVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'pageInfo' and self.page_info is not None:
+            return visitor._page_info(self.page_info)
+
+
+scout_compute_api_PageStrategy.__name__ = "PageStrategy"
+scout_compute_api_PageStrategy.__qualname__ = "PageStrategy"
+scout_compute_api_PageStrategy.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_PageStrategyVisitor:
+
+    @abstractmethod
+    def _page_info(self, page_info: "scout_compute_api_PageInfo") -> Any:
+        pass
+
+
+scout_compute_api_PageStrategyVisitor.__name__ = "PageStrategyVisitor"
+scout_compute_api_PageStrategyVisitor.__qualname__ = "PageStrategyVisitor"
+scout_compute_api_PageStrategyVisitor.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_ParameterInput(ConjureBeanType):
 
     @builtins.classmethod
@@ -34960,7 +34965,7 @@ class scout_compute_api_RangeAggregationOperation(ConjureUnionType):
     _min: Optional["scout_compute_api_Minimum"] = None
     _max: Optional["scout_compute_api_Maximum"] = None
     _standard_deviation: Optional["scout_compute_api_StandardDeviation"] = None
-    _all: Optional["scout_compute_api_Empty"] = None
+    _all: Optional["api_Empty"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
@@ -34969,7 +34974,7 @@ class scout_compute_api_RangeAggregationOperation(ConjureUnionType):
             'min': ConjureFieldDefinition('min', scout_compute_api_Minimum),
             'max': ConjureFieldDefinition('max', scout_compute_api_Maximum),
             'standard_deviation': ConjureFieldDefinition('standardDeviation', scout_compute_api_StandardDeviation),
-            'all': ConjureFieldDefinition('all', scout_compute_api_Empty)
+            'all': ConjureFieldDefinition('all', api_Empty)
         }
 
     def __init__(
@@ -34978,7 +34983,7 @@ class scout_compute_api_RangeAggregationOperation(ConjureUnionType):
             min: Optional["scout_compute_api_Minimum"] = None,
             max: Optional["scout_compute_api_Maximum"] = None,
             standard_deviation: Optional["scout_compute_api_StandardDeviation"] = None,
-            all: Optional["scout_compute_api_Empty"] = None,
+            all: Optional["api_Empty"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
@@ -35044,7 +35049,7 @@ class scout_compute_api_RangeAggregationOperation(ConjureUnionType):
         return self._standard_deviation
 
     @builtins.property
-    def all(self) -> Optional["scout_compute_api_Empty"]:
+    def all(self) -> Optional["api_Empty"]:
         return self._all
 
     def accept(self, visitor) -> Any:
@@ -35086,7 +35091,7 @@ class scout_compute_api_RangeAggregationOperationVisitor:
         pass
 
     @abstractmethod
-    def _all(self, all: "scout_compute_api_Empty") -> Any:
+    def _all(self, all: "api_Empty") -> Any:
         pass
 
 
@@ -35096,95 +35101,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 +35205,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 +35217,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 +35243,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 +35258,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 +35283,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 +35303,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 +35324,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 +35339,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 +35360,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 +35378,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 +35424,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 +35445,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 +35477,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 +35492,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"
@@ -35534,21 +35539,21 @@ scout_compute_api_RangeSummary.__module__ = "nominal_api.scout_compute_api"
 class scout_compute_api_RangeValue(ConjureUnionType):
     _double: Optional[float] = None
     _aggregation: Optional["scout_compute_api_RangeAggregation"] = None
-    _no_points_in_range: Optional["scout_compute_api_Empty"] = None
+    _no_points_in_range: Optional["api_Empty"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'double': ConjureFieldDefinition('double', float),
             'aggregation': ConjureFieldDefinition('aggregation', scout_compute_api_RangeAggregation),
-            'no_points_in_range': ConjureFieldDefinition('noPointsInRange', scout_compute_api_Empty)
+            'no_points_in_range': ConjureFieldDefinition('noPointsInRange', api_Empty)
         }
 
     def __init__(
             self,
             double: Optional[float] = None,
             aggregation: Optional["scout_compute_api_RangeAggregation"] = None,
-            no_points_in_range: Optional["scout_compute_api_Empty"] = None,
+            no_points_in_range: Optional["api_Empty"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
@@ -35590,7 +35595,7 @@ class scout_compute_api_RangeValue(ConjureUnionType):
         return self._aggregation
 
     @builtins.property
-    def no_points_in_range(self) -> Optional["scout_compute_api_Empty"]:
+    def no_points_in_range(self) -> Optional["api_Empty"]:
         return self._no_points_in_range
 
     def accept(self, visitor) -> Any:
@@ -35620,7 +35625,7 @@ class scout_compute_api_RangeValueVisitor:
         pass
 
     @abstractmethod
-    def _no_points_in_range(self, no_points_in_range: "scout_compute_api_Empty") -> Any:
+    def _no_points_in_range(self, no_points_in_range: "api_Empty") -> Any:
         pass
 
 
@@ -36081,7 +36086,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
 
@@ -37039,6 +37044,83 @@ scout_compute_api_SumSeries.__qualname__ = "SumSeries"
 scout_compute_api_SumSeries.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_SummarizationStrategy(ConjureUnionType):
+    _decimate: Optional["scout_compute_api_DecimateStrategy"] = None
+    _page: Optional["scout_compute_api_PageStrategy"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'decimate': ConjureFieldDefinition('decimate', scout_compute_api_DecimateStrategy),
+            'page': ConjureFieldDefinition('page', scout_compute_api_PageStrategy)
+        }
+
+    def __init__(
+            self,
+            decimate: Optional["scout_compute_api_DecimateStrategy"] = None,
+            page: Optional["scout_compute_api_PageStrategy"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (decimate is not None) + (page is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if decimate is not None:
+                self._decimate = decimate
+                self._type = 'decimate'
+            if page is not None:
+                self._page = page
+                self._type = 'page'
+
+        elif type_of_union == 'decimate':
+            if decimate is None:
+                raise ValueError('a union value must not be None')
+            self._decimate = decimate
+            self._type = 'decimate'
+        elif type_of_union == 'page':
+            if page is None:
+                raise ValueError('a union value must not be None')
+            self._page = page
+            self._type = 'page'
+
+    @builtins.property
+    def decimate(self) -> Optional["scout_compute_api_DecimateStrategy"]:
+        return self._decimate
+
+    @builtins.property
+    def page(self) -> Optional["scout_compute_api_PageStrategy"]:
+        return self._page
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_compute_api_SummarizationStrategyVisitor):
+            raise ValueError('{} is not an instance of scout_compute_api_SummarizationStrategyVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'decimate' and self.decimate is not None:
+            return visitor._decimate(self.decimate)
+        if self._type == 'page' and self.page is not None:
+            return visitor._page(self.page)
+
+
+scout_compute_api_SummarizationStrategy.__name__ = "SummarizationStrategy"
+scout_compute_api_SummarizationStrategy.__qualname__ = "SummarizationStrategy"
+scout_compute_api_SummarizationStrategy.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_SummarizationStrategyVisitor:
+
+    @abstractmethod
+    def _decimate(self, decimate: "scout_compute_api_DecimateStrategy") -> Any:
+        pass
+
+    @abstractmethod
+    def _page(self, page: "scout_compute_api_PageStrategy") -> Any:
+        pass
+
+
+scout_compute_api_SummarizationStrategyVisitor.__name__ = "SummarizationStrategyVisitor"
+scout_compute_api_SummarizationStrategyVisitor.__qualname__ = "SummarizationStrategyVisitor"
+scout_compute_api_SummarizationStrategyVisitor.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_SummarizeCartesian(ConjureBeanType):
 
     @builtins.classmethod
@@ -37142,8 +37224,8 @@ scout_compute_api_SummarizeRanges.__module__ = "nominal_api.scout_compute_api"
 
 class scout_compute_api_SummarizeSeries(ConjureBeanType):
     """
-    Summarizes the output of a series node. The output can be a numeric, enum, or cartesian series.
-Only resolution or buckets should be specified, not both.
+    Summarizes the output of a series node. The output can be a numeric, enum, log, or cartesian series.
+Summarization strategy should be specified.
     """
 
     @builtins.classmethod
@@ -37151,15 +37233,17 @@ Only resolution or buckets should be specified, not both.
         return {
             'input': ConjureFieldDefinition('input', scout_compute_api_Series),
             'resolution': ConjureFieldDefinition('resolution', OptionalTypeWrapper[int]),
-            'buckets': ConjureFieldDefinition('buckets', OptionalTypeWrapper[int])
+            'buckets': ConjureFieldDefinition('buckets', OptionalTypeWrapper[int]),
+            'summarization_strategy': ConjureFieldDefinition('summarizationStrategy', OptionalTypeWrapper[scout_compute_api_SummarizationStrategy])
         }
 
-    __slots__: List[str] = ['_input', '_resolution', '_buckets']
+    __slots__: List[str] = ['_input', '_resolution', '_buckets', '_summarization_strategy']
 
-    def __init__(self, input: "scout_compute_api_Series", buckets: Optional[int] = None, resolution: Optional[int] = None) -> None:
+    def __init__(self, input: "scout_compute_api_Series", buckets: Optional[int] = None, resolution: Optional[int] = None, summarization_strategy: Optional["scout_compute_api_SummarizationStrategy"] = None) -> None:
         self._input = input
         self._resolution = resolution
         self._buckets = buckets
+        self._summarization_strategy = summarization_strategy
 
     @builtins.property
     def input(self) -> "scout_compute_api_Series":
@@ -37180,6 +37264,13 @@ Picoseconds for picosecond-granularity dataset, nanoseconds otherwise.
         """
         return self._buckets
 
+    @builtins.property
+    def summarization_strategy(self) -> Optional["scout_compute_api_SummarizationStrategy"]:
+        """
+        The strategy to use when summarizing the series.
+        """
+        return self._summarization_strategy
+
 
 scout_compute_api_SummarizeSeries.__name__ = "SummarizeSeries"
 scout_compute_api_SummarizeSeries.__qualname__ = "SummarizeSeries"
@@ -42465,6 +42556,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 +44011,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 +44130,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 +44165,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 +44198,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 +44226,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 +44278,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 +44294,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 +44322,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 +44397,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 +44963,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 +44979,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 +44995,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 +45014,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 +45032,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 +45045,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 +45068,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"
@@ -45047,43 +45447,33 @@ scout_compute_resolved_api_SummarizeRangesNode.__module__ = "nominal_api.scout_c
 
 class scout_compute_resolved_api_SummarizeSeriesNode(ConjureBeanType):
     """
-    Summarizes the output of a series node. The output can be a numeric, enum, or cartesian series.
-Only resolution or buckets should be specified, not both.
+    Summarizes the output of a series node. The output can be a numeric, enum, log, or cartesian series.
+Summarization strategy should be specified.
     """
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'input': ConjureFieldDefinition('input', scout_compute_resolved_api_SeriesNode),
-            'resolution': ConjureFieldDefinition('resolution', OptionalTypeWrapper[int]),
-            'buckets': ConjureFieldDefinition('buckets', OptionalTypeWrapper[int])
+            'summarization_strategy': ConjureFieldDefinition('summarizationStrategy', scout_compute_api_SummarizationStrategy)
         }
 
-    __slots__: List[str] = ['_input', '_resolution', '_buckets']
+    __slots__: List[str] = ['_input', '_summarization_strategy']
 
-    def __init__(self, input: "scout_compute_resolved_api_SeriesNode", buckets: Optional[int] = None, resolution: Optional[int] = None) -> None:
+    def __init__(self, input: "scout_compute_resolved_api_SeriesNode", summarization_strategy: "scout_compute_api_SummarizationStrategy") -> None:
         self._input = input
-        self._resolution = resolution
-        self._buckets = buckets
+        self._summarization_strategy = summarization_strategy
 
     @builtins.property
     def input(self) -> "scout_compute_resolved_api_SeriesNode":
         return self._input
 
     @builtins.property
-    def resolution(self) -> Optional[int]:
-        """
-        Resolution of the output series specifying time interval between decimated points.
-Picoseconds for picosecond-granularity dataset, nanoseconds otherwise.
-        """
-        return self._resolution
-
-    @builtins.property
-    def buckets(self) -> Optional[int]:
+    def summarization_strategy(self) -> "scout_compute_api_SummarizationStrategy":
         """
-        Number of points to generate in the output series.
+        The strategy to use when summarizing the series.
         """
-        return self._buckets
+        return self._summarization_strategy
 
 
 scout_compute_resolved_api_SummarizeSeriesNode.__name__ = "SummarizeSeriesNode"
@@ -46083,7 +46473,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 +47179,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 +47265,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 +47317,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 +47838,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 +48151,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 +48587,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),
@@ -48251,7 +48641,7 @@ class scout_datareview_api_DataReviewPage(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'data_reviews': ConjureFieldDefinition('dataReviews', List[scout_datareview_api_DataReview]),
-            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[scout_api_Token])
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token])
         }
 
     __slots__: List[str] = ['_data_reviews', '_next_page_token']
@@ -49046,7 +49436,7 @@ If commitId is omitted from a ChecklistRef, it will match all commits.
             'run_rids': ConjureFieldDefinition('runRids', List[scout_run_api_RunRid]),
             'asset_rids': ConjureFieldDefinition('assetRids', List[scout_rids_api_AssetRid]),
             'checklist_refs': ConjureFieldDefinition('checklistRefs', List[scout_checks_api_ChecklistRef]),
-            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[scout_api_Token]),
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token]),
             'page_size': ConjureFieldDefinition('pageSize', OptionalTypeWrapper[int]),
             'show_archived': ConjureFieldDefinition('showArchived', OptionalTypeWrapper[bool]),
             'archived_statuses': ConjureFieldDefinition('archivedStatuses', OptionalTypeWrapper[List[api_ArchivedStatus]])
@@ -49113,7 +49503,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 +50122,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 +50688,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']
@@ -50321,7 +50711,7 @@ class scout_datareview_api_SearchCheckAlertsRequest(ConjureBeanType):
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[scout_api_Token]),
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token]),
             'page_size': ConjureFieldDefinition('pageSize', OptionalTypeWrapper[int]),
             'sort_by': ConjureFieldDefinition('sortBy', OptionalTypeWrapper[scout_datareview_api_SearchCheckAlertsSortOptions]),
             'search_text': ConjureFieldDefinition('searchText', OptionalTypeWrapper[str]),
@@ -50329,7 +50719,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]),
@@ -50469,7 +50859,7 @@ class scout_datareview_api_SearchCheckAlertsResponse(ConjureBeanType):
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[scout_api_Token]),
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token]),
             'check_alerts': ConjureFieldDefinition('checkAlerts', List[scout_datareview_api_CheckAlert])
         }
 
@@ -51804,22 +52194,6 @@ scout_datasource_connection_api_Duration.__qualname__ = "Duration"
 scout_datasource_connection_api_Duration.__module__ = "nominal_api.scout_datasource_connection_api"
 
 
-class scout_datasource_connection_api_Empty(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-        }
-
-    __slots__: List[str] = []
-
-
-
-scout_datasource_connection_api_Empty.__name__ = "Empty"
-scout_datasource_connection_api_Empty.__qualname__ = "Empty"
-scout_datasource_connection_api_Empty.__module__ = "nominal_api.scout_datasource_connection_api"
-
-
 class scout_datasource_connection_api_HeaderValue(ConjureUnionType):
     _plain: Optional[str] = None
     _secret_rid: Optional[str] = None
@@ -51995,25 +52369,25 @@ scout_datasource_connection_api_Influx2ConnectionDetails.__module__ = "nominal_a
 
 
 class scout_datasource_connection_api_InfluxChannelNameComponent(ConjureUnionType):
-    _bucket: Optional["scout_datasource_connection_api_Empty"] = None
-    _measurement: Optional["scout_datasource_connection_api_Empty"] = None
-    _field: Optional["scout_datasource_connection_api_Empty"] = None
+    _bucket: Optional["api_Empty"] = None
+    _measurement: Optional["api_Empty"] = None
+    _field: Optional["api_Empty"] = None
     _tag_value: Optional[str] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'bucket': ConjureFieldDefinition('bucket', scout_datasource_connection_api_Empty),
-            'measurement': ConjureFieldDefinition('measurement', scout_datasource_connection_api_Empty),
-            'field': ConjureFieldDefinition('field', scout_datasource_connection_api_Empty),
+            'bucket': ConjureFieldDefinition('bucket', api_Empty),
+            'measurement': ConjureFieldDefinition('measurement', api_Empty),
+            'field': ConjureFieldDefinition('field', api_Empty),
             'tag_value': ConjureFieldDefinition('tagValue', api_TagName)
         }
 
     def __init__(
             self,
-            bucket: Optional["scout_datasource_connection_api_Empty"] = None,
-            measurement: Optional["scout_datasource_connection_api_Empty"] = None,
-            field: Optional["scout_datasource_connection_api_Empty"] = None,
+            bucket: Optional["api_Empty"] = None,
+            measurement: Optional["api_Empty"] = None,
+            field: Optional["api_Empty"] = None,
             tag_value: Optional[str] = None,
             type_of_union: Optional[str] = None
             ) -> None:
@@ -52056,15 +52430,15 @@ class scout_datasource_connection_api_InfluxChannelNameComponent(ConjureUnionTyp
             self._type = 'tagValue'
 
     @builtins.property
-    def bucket(self) -> Optional["scout_datasource_connection_api_Empty"]:
+    def bucket(self) -> Optional["api_Empty"]:
         return self._bucket
 
     @builtins.property
-    def measurement(self) -> Optional["scout_datasource_connection_api_Empty"]:
+    def measurement(self) -> Optional["api_Empty"]:
         return self._measurement
 
     @builtins.property
-    def field(self) -> Optional["scout_datasource_connection_api_Empty"]:
+    def field(self) -> Optional["api_Empty"]:
         return self._field
 
     @builtins.property
@@ -52095,15 +52469,15 @@ scout_datasource_connection_api_InfluxChannelNameComponent.__module__ = "nominal
 class scout_datasource_connection_api_InfluxChannelNameComponentVisitor:
 
     @abstractmethod
-    def _bucket(self, bucket: "scout_datasource_connection_api_Empty") -> Any:
+    def _bucket(self, bucket: "api_Empty") -> Any:
         pass
 
     @abstractmethod
-    def _measurement(self, measurement: "scout_datasource_connection_api_Empty") -> Any:
+    def _measurement(self, measurement: "api_Empty") -> Any:
         pass
 
     @abstractmethod
-    def _field(self, field: "scout_datasource_connection_api_Empty") -> Any:
+    def _field(self, field: "api_Empty") -> Any:
         pass
 
     @abstractmethod
@@ -52309,19 +52683,19 @@ scout_datasource_connection_api_LimitsConfig.__module__ = "nominal_api.scout_dat
 
 
 class scout_datasource_connection_api_NominalChannelNameComponent(ConjureUnionType):
-    _channel: Optional["scout_datasource_connection_api_Empty"] = None
+    _channel: Optional["api_Empty"] = None
     _value_of_tag_with_name: Optional[str] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'channel': ConjureFieldDefinition('channel', scout_datasource_connection_api_Empty),
+            'channel': ConjureFieldDefinition('channel', api_Empty),
             'value_of_tag_with_name': ConjureFieldDefinition('valueOfTagWithName', api_TagName)
         }
 
     def __init__(
             self,
-            channel: Optional["scout_datasource_connection_api_Empty"] = None,
+            channel: Optional["api_Empty"] = None,
             value_of_tag_with_name: Optional[str] = None,
             type_of_union: Optional[str] = None
             ) -> None:
@@ -52348,7 +52722,7 @@ class scout_datasource_connection_api_NominalChannelNameComponent(ConjureUnionTy
             self._type = 'valueOfTagWithName'
 
     @builtins.property
-    def channel(self) -> Optional["scout_datasource_connection_api_Empty"]:
+    def channel(self) -> Optional["api_Empty"]:
         return self._channel
 
     @builtins.property
@@ -52375,7 +52749,7 @@ scout_datasource_connection_api_NominalChannelNameComponent.__module__ = "nomina
 class scout_datasource_connection_api_NominalChannelNameComponentVisitor:
 
     @abstractmethod
-    def _channel(self, channel: "scout_datasource_connection_api_Empty") -> Any:
+    def _channel(self, channel: "api_Empty") -> Any:
         pass
 
     @abstractmethod
@@ -52477,20 +52851,20 @@ scout_datasource_connection_api_PasswordCredentials.__module__ = "nominal_api.sc
 
 
 class scout_datasource_connection_api_PivotedTimescaleChannelNameComponent(ConjureUnionType):
-    _table: Optional["scout_datasource_connection_api_Empty"] = None
-    _name: Optional["scout_datasource_connection_api_Empty"] = None
+    _table: Optional["api_Empty"] = None
+    _name: Optional["api_Empty"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'table': ConjureFieldDefinition('table', scout_datasource_connection_api_Empty),
-            'name': ConjureFieldDefinition('name', scout_datasource_connection_api_Empty)
+            'table': ConjureFieldDefinition('table', api_Empty),
+            'name': ConjureFieldDefinition('name', api_Empty)
         }
 
     def __init__(
             self,
-            table: Optional["scout_datasource_connection_api_Empty"] = None,
-            name: Optional["scout_datasource_connection_api_Empty"] = None,
+            table: Optional["api_Empty"] = None,
+            name: Optional["api_Empty"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
@@ -52516,11 +52890,11 @@ class scout_datasource_connection_api_PivotedTimescaleChannelNameComponent(Conju
             self._type = 'name'
 
     @builtins.property
-    def table(self) -> Optional["scout_datasource_connection_api_Empty"]:
+    def table(self) -> Optional["api_Empty"]:
         return self._table
 
     @builtins.property
-    def name(self) -> Optional["scout_datasource_connection_api_Empty"]:
+    def name(self) -> Optional["api_Empty"]:
         """
         The value of the name column.
         """
@@ -52543,11 +52917,11 @@ scout_datasource_connection_api_PivotedTimescaleChannelNameComponent.__module__
 class scout_datasource_connection_api_PivotedTimescaleChannelNameComponentVisitor:
 
     @abstractmethod
-    def _table(self, table: "scout_datasource_connection_api_Empty") -> Any:
+    def _table(self, table: "api_Empty") -> Any:
         pass
 
     @abstractmethod
-    def _name(self, name: "scout_datasource_connection_api_Empty") -> Any:
+    def _name(self, name: "api_Empty") -> Any:
         pass
 
 
@@ -53010,25 +53384,25 @@ scout_datasource_connection_api_TimescaleScrapingFilterVisitor.__module__ = "nom
 
 
 class scout_datasource_connection_api_TimestreamChannelNameComponent(ConjureUnionType):
-    _table: Optional["scout_datasource_connection_api_Empty"] = None
-    _measure: Optional["scout_datasource_connection_api_Empty"] = None
-    _attribute: Optional["scout_datasource_connection_api_Empty"] = None
+    _table: Optional["api_Empty"] = None
+    _measure: Optional["api_Empty"] = None
+    _attribute: Optional["api_Empty"] = None
     _value_of_tag_with_name: Optional[str] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'table': ConjureFieldDefinition('table', scout_datasource_connection_api_Empty),
-            'measure': ConjureFieldDefinition('measure', scout_datasource_connection_api_Empty),
-            'attribute': ConjureFieldDefinition('attribute', scout_datasource_connection_api_Empty),
+            'table': ConjureFieldDefinition('table', api_Empty),
+            'measure': ConjureFieldDefinition('measure', api_Empty),
+            'attribute': ConjureFieldDefinition('attribute', api_Empty),
             'value_of_tag_with_name': ConjureFieldDefinition('valueOfTagWithName', api_TagName)
         }
 
     def __init__(
             self,
-            table: Optional["scout_datasource_connection_api_Empty"] = None,
-            measure: Optional["scout_datasource_connection_api_Empty"] = None,
-            attribute: Optional["scout_datasource_connection_api_Empty"] = None,
+            table: Optional["api_Empty"] = None,
+            measure: Optional["api_Empty"] = None,
+            attribute: Optional["api_Empty"] = None,
             value_of_tag_with_name: Optional[str] = None,
             type_of_union: Optional[str] = None
             ) -> None:
@@ -53071,15 +53445,15 @@ class scout_datasource_connection_api_TimestreamChannelNameComponent(ConjureUnio
             self._type = 'valueOfTagWithName'
 
     @builtins.property
-    def table(self) -> Optional["scout_datasource_connection_api_Empty"]:
+    def table(self) -> Optional["api_Empty"]:
         return self._table
 
     @builtins.property
-    def measure(self) -> Optional["scout_datasource_connection_api_Empty"]:
+    def measure(self) -> Optional["api_Empty"]:
         return self._measure
 
     @builtins.property
-    def attribute(self) -> Optional["scout_datasource_connection_api_Empty"]:
+    def attribute(self) -> Optional["api_Empty"]:
         return self._attribute
 
     @builtins.property
@@ -53110,15 +53484,15 @@ scout_datasource_connection_api_TimestreamChannelNameComponent.__module__ = "nom
 class scout_datasource_connection_api_TimestreamChannelNameComponentVisitor:
 
     @abstractmethod
-    def _table(self, table: "scout_datasource_connection_api_Empty") -> Any:
+    def _table(self, table: "api_Empty") -> Any:
         pass
 
     @abstractmethod
-    def _measure(self, measure: "scout_datasource_connection_api_Empty") -> Any:
+    def _measure(self, measure: "api_Empty") -> Any:
         pass
 
     @abstractmethod
-    def _attribute(self, attribute: "scout_datasource_connection_api_Empty") -> Any:
+    def _attribute(self, attribute: "api_Empty") -> Any:
         pass
 
     @abstractmethod
@@ -56560,7 +56934,7 @@ class scout_notebook_api_SearchNotebooksRequest(ConjureBeanType):
             'show_drafts': ConjureFieldDefinition('showDrafts', bool),
             'show_archived': ConjureFieldDefinition('showArchived', OptionalTypeWrapper[bool]),
             'sort_by': ConjureFieldDefinition('sortBy', OptionalTypeWrapper[scout_notebook_api_SortBy]),
-            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[scout_api_Token]),
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token]),
             'page_size': ConjureFieldDefinition('pageSize', OptionalTypeWrapper[int])
         }
 
@@ -56622,7 +56996,7 @@ class scout_notebook_api_SearchNotebooksResponse(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'results': ConjureFieldDefinition('results', List[scout_notebook_api_NotebookMetadataWithRid]),
-            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[scout_api_Token])
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token])
         }
 
     __slots__: List[str] = ['_results', '_next_page_token']
@@ -56984,22 +57358,6 @@ scout_rids_api_ClosedWithIgnoreAlertState.__qualname__ = "ClosedWithIgnoreAlertS
 scout_rids_api_ClosedWithIgnoreAlertState.__module__ = "nominal_api.scout_rids_api"
 
 
-class scout_rids_api_Empty(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-        }
-
-    __slots__: List[str] = []
-
-
-
-scout_rids_api_Empty.__name__ = "Empty"
-scout_rids_api_Empty.__qualname__ = "Empty"
-scout_rids_api_Empty.__module__ = "nominal_api.scout_rids_api"
-
-
 class scout_rids_api_PendingReviewAlertState(ConjureBeanType):
 
     @builtins.classmethod
@@ -58454,7 +58812,7 @@ class scout_run_api_SearchRunChannelsRequest(ConjureBeanType):
             'search_text': ConjureFieldDefinition('searchText', str),
             'ref_name_filter': ConjureFieldDefinition('refNameFilter', OptionalTypeWrapper[List[scout_api_DataSourceRefName]]),
             'previously_selected_channels': ConjureFieldDefinition('previouslySelectedChannels', Dict[scout_api_DataSourceRefName, List[api_Channel]]),
-            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[scout_api_Token]),
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token]),
             'page_size': ConjureFieldDefinition('pageSize', OptionalTypeWrapper[int])
         }
 
@@ -58505,7 +58863,7 @@ class scout_run_api_SearchRunChannelsResponse(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'results': ConjureFieldDefinition('results', List[scout_run_api_ChannelMetadata]),
-            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[scout_api_Token])
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token])
         }
 
     __slots__: List[str] = ['_results', '_next_page_token']
@@ -58535,7 +58893,7 @@ class scout_run_api_SearchRunsRequest(ConjureBeanType):
         return {
             'sort': ConjureFieldDefinition('sort', scout_run_api_SortOptions),
             'page_size': ConjureFieldDefinition('pageSize', int),
-            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[scout_api_Token]),
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token]),
             'query': ConjureFieldDefinition('query', scout_run_api_SearchQuery)
         }
 
@@ -58578,7 +58936,7 @@ class scout_run_api_SearchRunsResponse(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'results': ConjureFieldDefinition('results', List[scout_run_api_Run]),
-            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[scout_api_Token])
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token])
         }
 
     __slots__: List[str] = ['_results', '_next_page_token']
@@ -58607,7 +58965,7 @@ class scout_run_api_SearchRunsWithDataReviewMetricsResponse(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'results': ConjureFieldDefinition('results', List[scout_run_api_RunWithDataReviewMetrics]),
-            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[scout_api_Token])
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token])
         }
 
     __slots__: List[str] = ['_results', '_next_page_token']
@@ -58636,7 +58994,7 @@ class scout_run_api_SearchRunsWithDataReviewSummaryResponse(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'results': ConjureFieldDefinition('results', List[scout_run_api_RunWithDataReviewSummary]),
-            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[scout_api_Token])
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token])
         }
 
     __slots__: List[str] = ['_results', '_next_page_token']
@@ -59387,7 +59745,7 @@ class scout_template_api_SearchTemplatesRequest(ConjureBeanType):
         return {
             'query': ConjureFieldDefinition('query', scout_template_api_SearchTemplatesQuery),
             'sort_by': ConjureFieldDefinition('sortBy', OptionalTypeWrapper[scout_template_api_SortBy]),
-            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[scout_api_Token]),
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token]),
             'page_size': ConjureFieldDefinition('pageSize', OptionalTypeWrapper[int])
         }
 
@@ -59433,7 +59791,7 @@ class scout_template_api_SearchTemplatesResponse(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'results': ConjureFieldDefinition('results', List[scout_template_api_TemplateSummary]),
-            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[scout_api_Token])
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token])
         }
 
     __slots__: List[str] = ['_results', '_next_page_token']
@@ -59992,7 +60350,7 @@ class scout_versioning_api_CommitHistory(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'history': ConjureFieldDefinition('history', List[scout_versioning_api_Commit]),
-            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[scout_api_Token])
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token])
         }
 
     __slots__: List[str] = ['_history', '_next_page_token']
@@ -61173,22 +61531,6 @@ scout_video_api_DetailedIngestStatusVisitor.__qualname__ = "DetailedIngestStatus
 scout_video_api_DetailedIngestStatusVisitor.__module__ = "nominal_api.scout_video_api"
 
 
-class scout_video_api_Empty(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-        }
-
-    __slots__: List[str] = []
-
-
-
-scout_video_api_Empty.__name__ = "Empty"
-scout_video_api_Empty.__qualname__ = "Empty"
-scout_video_api_Empty.__module__ = "nominal_api.scout_video_api"
-
-
 class scout_video_api_ErrorIngestStatus(ConjureBeanType):
 
     @builtins.classmethod
@@ -61310,26 +61652,6 @@ scout_video_api_IngestError.__qualname__ = "IngestError"
 scout_video_api_IngestError.__module__ = "nominal_api.scout_video_api"
 
 
-class scout_video_api_IngestStatus(ConjureEnumType):
-
-    SUCCEEDED = 'SUCCEEDED'
-    '''SUCCEEDED'''
-    FAILED = 'FAILED'
-    '''FAILED'''
-    IN_PROGRESS = 'IN_PROGRESS'
-    '''IN_PROGRESS'''
-    UNKNOWN = 'UNKNOWN'
-    '''UNKNOWN'''
-
-    def __reduce_ex__(self, proto):
-        return self.__class__, (self.name,)
-
-
-scout_video_api_IngestStatus.__name__ = "IngestStatus"
-scout_video_api_IngestStatus.__qualname__ = "IngestStatus"
-scout_video_api_IngestStatus.__module__ = "nominal_api.scout_video_api"
-
-
 class scout_video_api_McapTimestampManifest(ConjureBeanType):
     """
     Timestamps are derived from the mcap file containing the video frames.
@@ -61502,7 +61824,7 @@ class scout_video_api_SearchVideosQuery(ConjureUnionType):
     _property: Optional["api_Property"] = None
     _and_: Optional[List["scout_video_api_SearchVideosQuery"]] = None
     _or_: Optional[List["scout_video_api_SearchVideosQuery"]] = None
-    _ingest_status: Optional["scout_video_api_IngestStatus"] = None
+    _ingest_status: Optional["api_IngestStatus"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
@@ -61512,7 +61834,7 @@ class scout_video_api_SearchVideosQuery(ConjureUnionType):
             'property': ConjureFieldDefinition('property', api_Property),
             'and_': ConjureFieldDefinition('and', List[scout_video_api_SearchVideosQuery]),
             'or_': ConjureFieldDefinition('or', List[scout_video_api_SearchVideosQuery]),
-            'ingest_status': ConjureFieldDefinition('ingestStatus', scout_video_api_IngestStatus)
+            'ingest_status': ConjureFieldDefinition('ingestStatus', api_IngestStatus)
         }
 
     def __init__(
@@ -61522,7 +61844,7 @@ class scout_video_api_SearchVideosQuery(ConjureUnionType):
             property: Optional["api_Property"] = None,
             and_: Optional[List["scout_video_api_SearchVideosQuery"]] = None,
             or_: Optional[List["scout_video_api_SearchVideosQuery"]] = None,
-            ingest_status: Optional["scout_video_api_IngestStatus"] = None,
+            ingest_status: Optional["api_IngestStatus"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
@@ -61600,7 +61922,7 @@ class scout_video_api_SearchVideosQuery(ConjureUnionType):
         return self._or_
 
     @builtins.property
-    def ingest_status(self) -> Optional["scout_video_api_IngestStatus"]:
+    def ingest_status(self) -> Optional["api_IngestStatus"]:
         return self._ingest_status
 
     def accept(self, visitor) -> Any:
@@ -61648,7 +61970,7 @@ class scout_video_api_SearchVideosQueryVisitor:
         pass
 
     @abstractmethod
-    def _ingest_status(self, ingest_status: "scout_video_api_IngestStatus") -> Any:
+    def _ingest_status(self, ingest_status: "api_IngestStatus") -> Any:
         pass
 
 
@@ -61664,7 +61986,7 @@ class scout_video_api_SearchVideosRequest(ConjureBeanType):
         return {
             'query': ConjureFieldDefinition('query', scout_video_api_SearchVideosQuery),
             'page_size': ConjureFieldDefinition('pageSize', OptionalTypeWrapper[int]),
-            'token': ConjureFieldDefinition('token', OptionalTypeWrapper[scout_backend_Token]),
+            'token': ConjureFieldDefinition('token', OptionalTypeWrapper[api_Token]),
             'sort_options': ConjureFieldDefinition('sortOptions', scout_video_api_SortOptions),
             'archived_statuses': ConjureFieldDefinition('archivedStatuses', OptionalTypeWrapper[List[api_ArchivedStatus]])
         }
@@ -61716,7 +62038,7 @@ class scout_video_api_SearchVideosResponse(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'results': ConjureFieldDefinition('results', List[scout_video_api_Video]),
-            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[scout_backend_Token])
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token])
         }
 
     __slots__: List[str] = ['_results', '_next_page_token']
@@ -61744,7 +62066,7 @@ class scout_video_api_Segment(ConjureBeanType):
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'rid': ConjureFieldDefinition('rid', scout_video_api_SegmentRid),
+            'rid': ConjureFieldDefinition('rid', api_rids_SegmentRid),
             'video_rid': ConjureFieldDefinition('videoRid', api_rids_VideoRid),
             'data_handle': ConjureFieldDefinition('dataHandle', api_Handle),
             'frame_rate': ConjureFieldDefinition('frameRate', float),
@@ -62025,21 +62347,21 @@ scout_video_api_TimestampMappings.__module__ = "nominal_api.scout_video_api"
 class scout_video_api_UpdateIngestStatus(ConjureUnionType):
     _success: Optional["scout_video_api_SuccessIngestStatus"] = None
     _error: Optional["scout_video_api_ErrorIngestStatus"] = None
-    _in_progress: Optional["scout_video_api_Empty"] = None
+    _in_progress: Optional["api_Empty"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'success': ConjureFieldDefinition('success', scout_video_api_SuccessIngestStatus),
             'error': ConjureFieldDefinition('error', scout_video_api_ErrorIngestStatus),
-            'in_progress': ConjureFieldDefinition('inProgress', scout_video_api_Empty)
+            'in_progress': ConjureFieldDefinition('inProgress', api_Empty)
         }
 
     def __init__(
             self,
             success: Optional["scout_video_api_SuccessIngestStatus"] = None,
             error: Optional["scout_video_api_ErrorIngestStatus"] = None,
-            in_progress: Optional["scout_video_api_Empty"] = None,
+            in_progress: Optional["api_Empty"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
@@ -62081,7 +62403,7 @@ class scout_video_api_UpdateIngestStatus(ConjureUnionType):
         return self._error
 
     @builtins.property
-    def in_progress(self) -> Optional["scout_video_api_Empty"]:
+    def in_progress(self) -> Optional["api_Empty"]:
         return self._in_progress
 
     def accept(self, visitor) -> Any:
@@ -62111,7 +62433,7 @@ class scout_video_api_UpdateIngestStatusVisitor:
         pass
 
     @abstractmethod
-    def _in_progress(self, in_progress: "scout_video_api_Empty") -> Any:
+    def _in_progress(self, in_progress: "api_Empty") -> Any:
         pass
 
 
@@ -62891,7 +63213,7 @@ class secrets_api_SearchSecretsRequest(ConjureBeanType):
             'query': ConjureFieldDefinition('query', secrets_api_SearchSecretsQuery),
             'page_size': ConjureFieldDefinition('pageSize', OptionalTypeWrapper[int]),
             'sort': ConjureFieldDefinition('sort', secrets_api_SortOptions),
-            'token': ConjureFieldDefinition('token', OptionalTypeWrapper[scout_backend_Token]),
+            'token': ConjureFieldDefinition('token', OptionalTypeWrapper[api_Token]),
             'archived_statuses': ConjureFieldDefinition('archivedStatuses', OptionalTypeWrapper[List[api_ArchivedStatus]])
         }
 
@@ -62942,7 +63264,7 @@ class secrets_api_SearchSecretsResponse(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'results': ConjureFieldDefinition('results', List[secrets_api_Secret]),
-            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[scout_backend_Token])
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token])
         }
 
     __slots__: List[str] = ['_results', '_next_page_token']
@@ -67133,22 +67455,6 @@ timeseries_logicalseries_api_CsvLocatorV2.__qualname__ = "CsvLocatorV2"
 timeseries_logicalseries_api_CsvLocatorV2.__module__ = "nominal_api.timeseries_logicalseries_api"
 
 
-class timeseries_logicalseries_api_Empty(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-        }
-
-    __slots__: List[str] = []
-
-
-
-timeseries_logicalseries_api_Empty.__name__ = "Empty"
-timeseries_logicalseries_api_Empty.__qualname__ = "Empty"
-timeseries_logicalseries_api_Empty.__module__ = "nominal_api.timeseries_logicalseries_api"
-
-
 class timeseries_logicalseries_api_GetSuggestedTagsRequest(ConjureBeanType):
 
     @builtins.classmethod
@@ -67959,19 +68265,19 @@ timeseries_logicalseries_api_TimestreamLocator.__module__ = "nominal_api.timeser
 class timeseries_logicalseries_api_UnitUpdate(ConjureUnionType):
     """UnitUpdate is used to either set a unit, or to clear an existing unit."""
     _unit: Optional[str] = None
-    _clear_unit: Optional["timeseries_logicalseries_api_Empty"] = None
+    _clear_unit: Optional["api_Empty"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'unit': ConjureFieldDefinition('unit', api_Unit),
-            'clear_unit': ConjureFieldDefinition('clearUnit', timeseries_logicalseries_api_Empty)
+            'clear_unit': ConjureFieldDefinition('clearUnit', api_Empty)
         }
 
     def __init__(
             self,
             unit: Optional[str] = None,
-            clear_unit: Optional["timeseries_logicalseries_api_Empty"] = None,
+            clear_unit: Optional["api_Empty"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
@@ -68001,7 +68307,7 @@ class timeseries_logicalseries_api_UnitUpdate(ConjureUnionType):
         return self._unit
 
     @builtins.property
-    def clear_unit(self) -> Optional["timeseries_logicalseries_api_Empty"]:
+    def clear_unit(self) -> Optional["api_Empty"]:
         return self._clear_unit
 
     def accept(self, visitor) -> Any:
@@ -68025,7 +68331,7 @@ class timeseries_logicalseries_api_UnitUpdateVisitor:
         pass
 
     @abstractmethod
-    def _clear_unit(self, clear_unit: "timeseries_logicalseries_api_Empty") -> Any:
+    def _clear_unit(self, clear_unit: "api_Empty") -> Any:
         pass
 
 
@@ -69092,8 +69398,6 @@ authentication_api_OrgRid = str
 
 themes_api_ChartThemeRid = str
 
-scout_datareview_api_DataReviewRid = str
-
 scout_rids_api_SnapshotRid = str
 
 scout_units_api_UnitName = str
@@ -69104,8 +69408,6 @@ timeseries_seriescache_api_Resolution = int
 
 api_PropertyName = str
 
-scout_catalog_ErrorType = str
-
 scout_integrations_api_IntegrationRid = str
 
 scout_api_DataSourceRefName = str
@@ -69134,8 +69436,6 @@ scout_rids_api_FunctionRid = str
 
 scout_units_api_UnitSystem = str
 
-scout_video_api_SegmentRid = str
-
 secrets_api_SecretRid = str
 
 timeseries_logicalseries_api_ColumnName = str
@@ -69150,7 +69450,7 @@ scout_compute_api_ErrorCode = int
 
 api_rids_ChunkRid = str
 
-datasource_Token = str
+scout_rids_api_CheckAlertRid = str
 
 scout_chart_api_JsonString = str
 
@@ -69164,6 +69464,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
@@ -69172,8 +69474,6 @@ scout_run_api_RunRid = str
 
 scout_datasource_connection_api_DatasetName = str
 
-scout_backend_Token = str
-
 api_TagValue = str
 
 scout_versioning_api_TagName = str
@@ -69212,8 +69512,6 @@ scout_channelvariables_api_ComputeSpecV1 = str
 
 timeseries_logicalseries_api_TableName = str
 
-scout_api_Token = str
-
 scout_rids_api_NotebookRid = str
 
 scout_asset_api_SeriesTagValue = str
@@ -69222,12 +69520,8 @@ scout_rids_api_UserRid = str
 
 api_rids_DatasetRid = str
 
-scout_datareview_api_CheckAlertRid = str
-
 scout_units_api_UnitSymbol = str
 
-datasource_logset_api_Token = str
-
 timeseries_logicalseries_api_LocationName = str
 
 api_rids_DataSourceRid = str
@@ -69242,8 +69536,6 @@ scout_video_api_ErrorType = str
 
 scout_comparisonnotebook_api_ComparisonChannelVariableMap = Dict[scout_comparisonnotebook_api_VariableName, scout_comparisonnotebook_api_ChannelVariable]
 
-ingest_api_ErrorType = str
-
 timeseries_logicalseries_api_FieldName = str
 
 scout_channelvariables_api_WorkbookChannelVariableMap = Dict[scout_channelvariables_api_ChannelVariableName, scout_channelvariables_api_ChannelVariable]
@@ -69258,6 +69550,8 @@ datasource_logset_api_LogSetRid = str
 
 ingest_api_DataSourceRefName = str
 
+api_ErrorType = str
+
 scout_compute_api_ComputeWithUnitsRequest = scout_compute_api_ComputeNodeRequest
 
 scout_compute_api_FunctionReference = str
@@ -69334,6 +69628,8 @@ scout_datasource_connection_api_OrganizationRid = str
 
 scout_rids_api_CheckRid = str
 
+api_Token = str
+
 timeseries_logicalseries_api_ProjectName = str
 
 api_Channel = str