nominal-api 0.551.0__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
@@ -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
@@ -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'
@@ -34482,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
@@ -34901,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]:
@@ -34910,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__(
@@ -34919,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:
@@ -34985,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:
@@ -35027,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
 
 
@@ -35475,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:
@@ -35531,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:
@@ -35561,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
 
 
@@ -36980,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
@@ -37083,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
@@ -37092,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":
@@ -37121,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"
@@ -45297,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]:
+    def summarization_strategy(self) -> "scout_compute_api_SummarizationStrategy":
         """
-        Resolution of the output series specifying time interval between decimated points.
-Picoseconds for picosecond-granularity dataset, nanoseconds otherwise.
+        The strategy to use when summarizing the series.
         """
-        return self._resolution
-
-    @builtins.property
-    def buckets(self) -> Optional[int]:
-        """
-        Number of points to generate in the output series.
-        """
-        return self._buckets
+        return self._summarization_strategy
 
 
 scout_compute_resolved_api_SummarizeSeriesNode.__name__ = "SummarizeSeriesNode"
@@ -48501,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']
@@ -49296,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]])
@@ -50571,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]),
@@ -50719,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])
         }
 
@@ -52054,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
@@ -52245,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:
@@ -52306,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
@@ -52345,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
@@ -52559,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:
@@ -52598,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
@@ -52625,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
@@ -52727,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:
@@ -52766,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.
         """
@@ -52793,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
 
 
@@ -53260,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:
@@ -53321,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
@@ -53360,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
@@ -56810,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])
         }
 
@@ -56872,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']
@@ -57234,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
@@ -58704,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])
         }
 
@@ -58755,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']
@@ -58785,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)
         }
 
@@ -58828,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']
@@ -58857,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']
@@ -58886,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']
@@ -59637,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])
         }
 
@@ -59683,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']
@@ -60242,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']
@@ -61423,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
@@ -61560,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.
@@ -61752,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]:
@@ -61762,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__(
@@ -61772,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:
@@ -61850,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:
@@ -61898,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
 
 
@@ -61914,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]])
         }
@@ -61966,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']
@@ -61994,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),
@@ -62275,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:
@@ -62331,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:
@@ -62361,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
 
 
@@ -63141,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]])
         }
 
@@ -63192,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']
@@ -67383,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
@@ -68209,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:
@@ -68251,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:
@@ -68275,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
 
 
@@ -69352,8 +69408,6 @@ timeseries_seriescache_api_Resolution = int
 
 api_PropertyName = str
 
-scout_catalog_ErrorType = str
-
 scout_integrations_api_IntegrationRid = str
 
 scout_api_DataSourceRefName = str
@@ -69382,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
@@ -69400,8 +69452,6 @@ api_rids_ChunkRid = str
 
 scout_rids_api_CheckAlertRid = str
 
-datasource_Token = str
-
 scout_chart_api_JsonString = str
 
 scout_checks_api_JobRid = str
@@ -69424,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
@@ -69464,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
@@ -69476,8 +69522,6 @@ api_rids_DatasetRid = str
 
 scout_units_api_UnitSymbol = str
 
-datasource_logset_api_Token = str
-
 timeseries_logicalseries_api_LocationName = str
 
 api_rids_DataSourceRid = str
@@ -69492,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]
@@ -69508,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
@@ -69584,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