nominal-api 0.1037.0__py3-none-any.whl → 0.1056.0__py3-none-any.whl

nominal_api/_impl.py

@@ -66,6 +66,38 @@ api_DataSourceType.__qualname__ = "DataSourceType"
 api_DataSourceType.__module__ = "nominal_api.api"
 
 
+class api_Deleted(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+        }
+
+    __slots__: List[str] = []
+
+
+
+api_Deleted.__name__ = "Deleted"
+api_Deleted.__qualname__ = "Deleted"
+api_Deleted.__module__ = "nominal_api.api"
+
+
+class api_DeletionInProgress(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+        }
+
+    __slots__: List[str] = []
+
+
+
+api_DeletionInProgress.__name__ = "DeletionInProgress"
+api_DeletionInProgress.__qualname__ = "DeletionInProgress"
+api_DeletionInProgress.__module__ = "nominal_api.api"
+
+
 class api_Empty(ConjureBeanType):
 
     @builtins.classmethod
@@ -225,13 +257,17 @@ class api_IngestStatusV2(ConjureUnionType):
     _success: Optional["api_SuccessResult"] = None
     _error: Optional["api_ErrorResult"] = None
     _in_progress: Optional["api_InProgressResult"] = None
+    _deletion_in_progress: Optional["api_DeletionInProgress"] = None
+    _deleted: Optional["api_Deleted"] = 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)
+            'in_progress': ConjureFieldDefinition('inProgress', api_InProgressResult),
+            'deletion_in_progress': ConjureFieldDefinition('deletionInProgress', api_DeletionInProgress),
+            'deleted': ConjureFieldDefinition('deleted', api_Deleted)
         }
 
     def __init__(
@@ -239,10 +275,12 @@ class api_IngestStatusV2(ConjureUnionType):
             success: Optional["api_SuccessResult"] = None,
             error: Optional["api_ErrorResult"] = None,
             in_progress: Optional["api_InProgressResult"] = None,
+            deletion_in_progress: Optional["api_DeletionInProgress"] = None,
+            deleted: Optional["api_Deleted"] = 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:
+            if (success is not None) + (error is not None) + (in_progress is not None) + (deletion_in_progress is not None) + (deleted is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if success is not None:
@@ -254,6 +292,12 @@ class api_IngestStatusV2(ConjureUnionType):
             if in_progress is not None:
                 self._in_progress = in_progress
                 self._type = 'inProgress'
+            if deletion_in_progress is not None:
+                self._deletion_in_progress = deletion_in_progress
+                self._type = 'deletionInProgress'
+            if deleted is not None:
+                self._deleted = deleted
+                self._type = 'deleted'
 
         elif type_of_union == 'success':
             if success is None:
@@ -270,6 +314,16 @@ class api_IngestStatusV2(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._in_progress = in_progress
             self._type = 'inProgress'
+        elif type_of_union == 'deletionInProgress':
+            if deletion_in_progress is None:
+                raise ValueError('a union value must not be None')
+            self._deletion_in_progress = deletion_in_progress
+            self._type = 'deletionInProgress'
+        elif type_of_union == 'deleted':
+            if deleted is None:
+                raise ValueError('a union value must not be None')
+            self._deleted = deleted
+            self._type = 'deleted'
 
     @builtins.property
     def success(self) -> Optional["api_SuccessResult"]:
@@ -283,6 +337,14 @@ class api_IngestStatusV2(ConjureUnionType):
     def in_progress(self) -> Optional["api_InProgressResult"]:
         return self._in_progress
 
+    @builtins.property
+    def deletion_in_progress(self) -> Optional["api_DeletionInProgress"]:
+        return self._deletion_in_progress
+
+    @builtins.property
+    def deleted(self) -> Optional["api_Deleted"]:
+        return self._deleted
+
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, api_IngestStatusV2Visitor):
             raise ValueError('{} is not an instance of api_IngestStatusV2Visitor'.format(visitor.__class__.__name__))
@@ -292,6 +354,10 @@ class api_IngestStatusV2(ConjureUnionType):
             return visitor._error(self.error)
         if self._type == 'inProgress' and self.in_progress is not None:
             return visitor._in_progress(self.in_progress)
+        if self._type == 'deletionInProgress' and self.deletion_in_progress is not None:
+            return visitor._deletion_in_progress(self.deletion_in_progress)
+        if self._type == 'deleted' and self.deleted is not None:
+            return visitor._deleted(self.deleted)
 
 
 api_IngestStatusV2.__name__ = "IngestStatusV2"
@@ -313,6 +379,14 @@ class api_IngestStatusV2Visitor:
     def _in_progress(self, in_progress: "api_InProgressResult") -> Any:
         pass
 
+    @abstractmethod
+    def _deletion_in_progress(self, deletion_in_progress: "api_DeletionInProgress") -> Any:
+        pass
+
+    @abstractmethod
+    def _deleted(self, deleted: "api_Deleted") -> Any:
+        pass
+
 
 api_IngestStatusV2Visitor.__name__ = "IngestStatusV2Visitor"
 api_IngestStatusV2Visitor.__qualname__ = "IngestStatusV2Visitor"
@@ -1726,6 +1800,137 @@ Requires authentication with Nominal. This endpoint is intended for internal use
         _decoder = ConjureDecoder()
         return _decoder.decode(_response.json(), authentication_api_GenerateMediaMtxTokenResponse, self._return_none_for_unknown_union_types)
 
+    def get_my_coachmark_dismissals(self, auth_header: str, request: "authentication_api_GetCoachmarkDismissalsRequest") -> "authentication_api_GetCoachmarkDismissalsResponse":
+        """Gets coachmark dismissals for the authenticated user.
+Optionally filter by specific coachmark IDs.
+        """
+        _conjure_encoder = ConjureEncoder()
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, str] = {
+        }
+
+        _json: Any = _conjure_encoder.default(request)
+
+        _path = '/authentication/v2/my/coachmarks/dismissals'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'POST',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        _decoder = ConjureDecoder()
+        return _decoder.decode(_response.json(), authentication_api_GetCoachmarkDismissalsResponse, self._return_none_for_unknown_union_types)
+
+    def dismiss_my_coachmark(self, auth_header: str, request: "authentication_api_DismissCoachmarkRequest") -> "authentication_api_CoachmarkDismissal":
+        """Dismisses a coachmark for the authenticated user.
+Records the dismissal timestamp and app version.
+        """
+        _conjure_encoder = ConjureEncoder()
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, str] = {
+        }
+
+        _json: Any = _conjure_encoder.default(request)
+
+        _path = '/authentication/v2/my/coachmarks/dismiss'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'POST',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        _decoder = ConjureDecoder()
+        return _decoder.decode(_response.json(), authentication_api_CoachmarkDismissal, self._return_none_for_unknown_union_types)
+
+    def is_my_coachmark_dismissed(self, auth_header: str, coachmark_id: str) -> bool:
+        """Checks if a specific coachmark has been dismissed by the authenticated user.
+        """
+        _conjure_encoder = ConjureEncoder()
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, str] = {
+            'coachmarkId': quote(str(_conjure_encoder.default(coachmark_id)), safe=''),
+        }
+
+        _json: Any = None
+
+        _path = '/authentication/v2/my/coachmarks/dismissed/{coachmarkId}'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'GET',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        _decoder = ConjureDecoder()
+        return _decoder.decode(_response.json(), bool, self._return_none_for_unknown_union_types)
+
+    def reset_my_coachmark_dismissal(self, auth_header: str, coachmark_id: str) -> None:
+        """Resets a coachmark dismissal for the authenticated user.
+This allows the coachmark to be shown again.
+Primarily intended for testing and debugging.
+        """
+        _conjure_encoder = ConjureEncoder()
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, str] = {
+            'coachmarkId': quote(str(_conjure_encoder.default(coachmark_id)), safe=''),
+        }
+
+        _json: Any = None
+
+        _path = '/authentication/v2/my/coachmarks/dismissals/{coachmarkId}'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'DELETE',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        return
+
 
 authentication_api_AuthenticationServiceV2.__name__ = "AuthenticationServiceV2"
 authentication_api_AuthenticationServiceV2.__qualname__ = "AuthenticationServiceV2"
@@ -1754,6 +1959,59 @@ authentication_api_ChartTooltipModeSetting.__qualname__ = "ChartTooltipModeSetti
 authentication_api_ChartTooltipModeSetting.__module__ = "nominal_api.authentication_api"
 
 
+class authentication_api_CoachmarkDismissal(ConjureBeanType):
+    """A record of a coachmark dismissal, including when it was dismissed
+and on which app version.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'coachmark_id': ConjureFieldDefinition('coachmarkId', str),
+            'dismissed_at': ConjureFieldDefinition('dismissedAt', str),
+            'app_version': ConjureFieldDefinition('appVersion', str),
+            'step_index': ConjureFieldDefinition('stepIndex', OptionalTypeWrapper[int])
+        }
+
+    __slots__: List[str] = ['_coachmark_id', '_dismissed_at', '_app_version', '_step_index']
+
+    def __init__(self, app_version: str, coachmark_id: str, dismissed_at: str, step_index: Optional[int] = None) -> None:
+        self._coachmark_id = coachmark_id
+        self._dismissed_at = dismissed_at
+        self._app_version = app_version
+        self._step_index = step_index
+
+    @builtins.property
+    def coachmark_id(self) -> str:
+        """The coachmark identifier (typically the feature flag name)
+        """
+        return self._coachmark_id
+
+    @builtins.property
+    def dismissed_at(self) -> str:
+        """ISO 8601 timestamp of when the coachmark was dismissed
+        """
+        return self._dismissed_at
+
+    @builtins.property
+    def app_version(self) -> str:
+        """The apps-scout version (semver) when the coachmark was dismissed
+        """
+        return self._app_version
+
+    @builtins.property
+    def step_index(self) -> Optional[int]:
+        """The step index when dismissed (for multi-step coachmarks).
+If not present, the coachmark was dismissed via the X button.
+        """
+        return self._step_index
+
+
+authentication_api_CoachmarkDismissal.__name__ = "CoachmarkDismissal"
+authentication_api_CoachmarkDismissal.__qualname__ = "CoachmarkDismissal"
+authentication_api_CoachmarkDismissal.__module__ = "nominal_api.authentication_api"
+
+
 class authentication_api_DefaultTimeRangeTypeSetting(ConjureEnumType):
 
     DEFAULT = 'DEFAULT'
@@ -1774,6 +2032,49 @@ authentication_api_DefaultTimeRangeTypeSetting.__qualname__ = "DefaultTimeRangeT
 authentication_api_DefaultTimeRangeTypeSetting.__module__ = "nominal_api.authentication_api"
 
 
+class authentication_api_DismissCoachmarkRequest(ConjureBeanType):
+    """Request to dismiss a coachmark
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'coachmark_id': ConjureFieldDefinition('coachmarkId', str),
+            'app_version': ConjureFieldDefinition('appVersion', str),
+            'step_index': ConjureFieldDefinition('stepIndex', OptionalTypeWrapper[int])
+        }
+
+    __slots__: List[str] = ['_coachmark_id', '_app_version', '_step_index']
+
+    def __init__(self, app_version: str, coachmark_id: str, step_index: Optional[int] = None) -> None:
+        self._coachmark_id = coachmark_id
+        self._app_version = app_version
+        self._step_index = step_index
+
+    @builtins.property
+    def coachmark_id(self) -> str:
+        """The coachmark identifier to dismiss
+        """
+        return self._coachmark_id
+
+    @builtins.property
+    def app_version(self) -> str:
+        """The apps-scout version (semver) when dismissing
+        """
+        return self._app_version
+
+    @builtins.property
+    def step_index(self) -> Optional[int]:
+        """The step index when dismissed (for multi-step coachmarks)
+        """
+        return self._step_index
+
+
+authentication_api_DismissCoachmarkRequest.__name__ = "DismissCoachmarkRequest"
+authentication_api_DismissCoachmarkRequest.__qualname__ = "DismissCoachmarkRequest"
+authentication_api_DismissCoachmarkRequest.__module__ = "nominal_api.authentication_api"
+
+
 class authentication_api_GenerateMediaMtxTokenRequest(ConjureBeanType):
     """Request to generate a MediaMTX authentication token
     """
@@ -1828,6 +2129,61 @@ authentication_api_GenerateMediaMtxTokenResponse.__qualname__ = "GenerateMediaMt
 authentication_api_GenerateMediaMtxTokenResponse.__module__ = "nominal_api.authentication_api"
 
 
+class authentication_api_GetCoachmarkDismissalsRequest(ConjureBeanType):
+    """Request to get coachmark dismissals
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'coachmark_ids': ConjureFieldDefinition('coachmarkIds', OptionalTypeWrapper[List[str]])
+        }
+
+    __slots__: List[str] = ['_coachmark_ids']
+
+    def __init__(self, coachmark_ids: Optional[List[str]] = None) -> None:
+        self._coachmark_ids = coachmark_ids
+
+    @builtins.property
+    def coachmark_ids(self) -> Optional[List[str]]:
+        """Optional list of coachmark IDs to filter by.
+If empty, returns all dismissals for the user.
+        """
+        return self._coachmark_ids
+
+
+authentication_api_GetCoachmarkDismissalsRequest.__name__ = "GetCoachmarkDismissalsRequest"
+authentication_api_GetCoachmarkDismissalsRequest.__qualname__ = "GetCoachmarkDismissalsRequest"
+authentication_api_GetCoachmarkDismissalsRequest.__module__ = "nominal_api.authentication_api"
+
+
+class authentication_api_GetCoachmarkDismissalsResponse(ConjureBeanType):
+    """Response containing coachmark dismissals
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'dismissals': ConjureFieldDefinition('dismissals', Dict[str, authentication_api_CoachmarkDismissal])
+        }
+
+    __slots__: List[str] = ['_dismissals']
+
+    def __init__(self, dismissals: Dict[str, "authentication_api_CoachmarkDismissal"]) -> None:
+        self._dismissals = dismissals
+
+    @builtins.property
+    def dismissals(self) -> Dict[str, "authentication_api_CoachmarkDismissal"]:
+        """Map of coachmark ID to dismissal record
+        """
+        return self._dismissals
+
+
+authentication_api_GetCoachmarkDismissalsResponse.__name__ = "GetCoachmarkDismissalsResponse"
+authentication_api_GetCoachmarkDismissalsResponse.__qualname__ = "GetCoachmarkDismissalsResponse"
+authentication_api_GetCoachmarkDismissalsResponse.__module__ = "nominal_api.authentication_api"
+
+
 class authentication_api_Jwk(ConjureBeanType):
     """A JSON Web Key (JWK) representation for RSA public keys
     """
@@ -4244,6 +4600,107 @@ datasource_TimestampType.__qualname__ = "TimestampType"
 datasource_TimestampType.__module__ = "nominal_api.datasource"
 
 
+class datasource_VideoFileMetadata(ConjureBeanType):
+    """Metadata specific to video files.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'timestamp_manifest': ConjureFieldDefinition('timestampManifest', scout_video_api_VideoFileTimestampManifest),
+            'segment_metadata': ConjureFieldDefinition('segmentMetadata', OptionalTypeWrapper[datasource_VideoSegmentsMetadata])
+        }
+
+    __slots__: List[str] = ['_timestamp_manifest', '_segment_metadata']
+
+    def __init__(self, timestamp_manifest: "scout_video_api_VideoFileTimestampManifest", segment_metadata: Optional["datasource_VideoSegmentsMetadata"] = None) -> None:
+        self._timestamp_manifest = timestamp_manifest
+        self._segment_metadata = segment_metadata
+
+    @builtins.property
+    def timestamp_manifest(self) -> "scout_video_api_VideoFileTimestampManifest":
+        """Specifies how to determine absolute timestamps for each frame in the video.
+Can be an embedded MCAP manifest, an external sidecar file, or calculated
+from a starting offset applied to presentation timestamps.
+        """
+        return self._timestamp_manifest
+
+    @builtins.property
+    def segment_metadata(self) -> Optional["datasource_VideoSegmentsMetadata"]:
+        """Cached aggregate metadata about the segments comprising this video file
+after segmentation has completed. Includes frame counts, duration, and
+frame rate. Empty until segmentation is complete.
+Note: Min/max timestamps are stored in DatasetFile.bounds field.
+Raw file size is stored in DatasetFile.fileSizeBytes.
+        """
+        return self._segment_metadata
+
+
+datasource_VideoFileMetadata.__name__ = "VideoFileMetadata"
+datasource_VideoFileMetadata.__qualname__ = "VideoFileMetadata"
+datasource_VideoFileMetadata.__module__ = "nominal_api.datasource"
+
+
+class datasource_VideoSegmentsMetadata(ConjureBeanType):
+    """Segment metadata for video files.
+Lightweight version that excludes bounds and RID since those are stored elsewhere.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'num_frames': ConjureFieldDefinition('numFrames', int),
+            'num_segments': ConjureFieldDefinition('numSegments', int),
+            'scale_factor': ConjureFieldDefinition('scaleFactor', float),
+            'media_duration_seconds': ConjureFieldDefinition('mediaDurationSeconds', float),
+            'media_frame_rate': ConjureFieldDefinition('mediaFrameRate', float)
+        }
+
+    __slots__: List[str] = ['_num_frames', '_num_segments', '_scale_factor', '_media_duration_seconds', '_media_frame_rate']
+
+    def __init__(self, media_duration_seconds: float, media_frame_rate: float, num_frames: int, num_segments: int, scale_factor: float) -> None:
+        self._num_frames = num_frames
+        self._num_segments = num_segments
+        self._scale_factor = scale_factor
+        self._media_duration_seconds = media_duration_seconds
+        self._media_frame_rate = media_frame_rate
+
+    @builtins.property
+    def num_frames(self) -> int:
+        """Total number of frames across all segments.
+        """
+        return self._num_frames
+
+    @builtins.property
+    def num_segments(self) -> int:
+        """Number of segments the video was split into.
+        """
+        return self._num_segments
+
+    @builtins.property
+    def scale_factor(self) -> float:
+        """Scale factor applied to timestamps during segmentation.
+        """
+        return self._scale_factor
+
+    @builtins.property
+    def media_duration_seconds(self) -> float:
+        """Total duration of the video in seconds.
+        """
+        return self._media_duration_seconds
+
+    @builtins.property
+    def media_frame_rate(self) -> float:
+        """Average frame rate (FPS) calculated as total frames / duration.
+        """
+        return self._media_frame_rate
+
+
+datasource_VideoSegmentsMetadata.__name__ = "VideoSegmentsMetadata"
+datasource_VideoSegmentsMetadata.__qualname__ = "VideoSegmentsMetadata"
+datasource_VideoSegmentsMetadata.__module__ = "nominal_api.datasource"
+
+
 class datasource_api_BatchGetChannelPrefixTreeRequest(ConjureBeanType):
 
     @builtins.classmethod
@@ -17770,6 +18227,35 @@ module_internal_ModuleComputeDefinition.__qualname__ = "ModuleComputeDefinition"
 module_internal_ModuleComputeDefinition.__module__ = "nominal_api.module_internal"
 
 
+class persistent_compute_api_AppendOnlyConfig(ConjureBeanType):
+    """Defines the append results from the websocket.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'decimate_results': ConjureFieldDefinition('decimateResults', bool)
+        }
+
+    __slots__: List[str] = ['_decimate_results']
+
+    def __init__(self, decimate_results: bool) -> None:
+        self._decimate_results = decimate_results
+
+    @builtins.property
+    def decimate_results(self) -> bool:
+        """Specifies whether the returned results should be decimated.
+If this is false, the client may receive a `SubscriptionCreationError` if the data rate is too high
+and responses must be decimated.
+        """
+        return self._decimate_results
+
+
+persistent_compute_api_AppendOnlyConfig.__name__ = "AppendOnlyConfig"
+persistent_compute_api_AppendOnlyConfig.__qualname__ = "AppendOnlyConfig"
+persistent_compute_api_AppendOnlyConfig.__module__ = "nominal_api.persistent_compute_api"
+
+
 class persistent_compute_api_AppendResult(ConjureBeanType):
     """An append result won't cover the full `StreamingComputeNodeRequest#windowWidth` but rather just a smaller 
 window. The end of the window that the append covers is guaranteed to be later than previously sent results.
@@ -18716,6 +19202,62 @@ persistent_compute_api_Pong.__qualname__ = "Pong"
 persistent_compute_api_Pong.__module__ = "nominal_api.persistent_compute_api"
 
 
+class persistent_compute_api_ResultConfiguration(ConjureUnionType):
+    _append_only: Optional["persistent_compute_api_AppendOnlyConfig"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'append_only': ConjureFieldDefinition('appendOnly', persistent_compute_api_AppendOnlyConfig)
+        }
+
+    def __init__(
+            self,
+            append_only: Optional["persistent_compute_api_AppendOnlyConfig"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (append_only is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if append_only is not None:
+                self._append_only = append_only
+                self._type = 'appendOnly'
+
+        elif type_of_union == 'appendOnly':
+            if append_only is None:
+                raise ValueError('a union value must not be None')
+            self._append_only = append_only
+            self._type = 'appendOnly'
+
+    @builtins.property
+    def append_only(self) -> Optional["persistent_compute_api_AppendOnlyConfig"]:
+        return self._append_only
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, persistent_compute_api_ResultConfigurationVisitor):
+            raise ValueError('{} is not an instance of persistent_compute_api_ResultConfigurationVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'appendOnly' and self.append_only is not None:
+            return visitor._append_only(self.append_only)
+
+
+persistent_compute_api_ResultConfiguration.__name__ = "ResultConfiguration"
+persistent_compute_api_ResultConfiguration.__qualname__ = "ResultConfiguration"
+persistent_compute_api_ResultConfiguration.__module__ = "nominal_api.persistent_compute_api"
+
+
+class persistent_compute_api_ResultConfigurationVisitor:
+
+    @abstractmethod
+    def _append_only(self, append_only: "persistent_compute_api_AppendOnlyConfig") -> Any:
+        pass
+
+
+persistent_compute_api_ResultConfigurationVisitor.__name__ = "ResultConfigurationVisitor"
+persistent_compute_api_ResultConfigurationVisitor.__qualname__ = "ResultConfigurationVisitor"
+persistent_compute_api_ResultConfigurationVisitor.__module__ = "nominal_api.persistent_compute_api"
+
+
 class persistent_compute_api_ServerMessage(ConjureUnionType):
     _subscription_update: Optional["persistent_compute_api_SubscriptionUpdateMessage"] = None
     _subscription_creation: Optional["persistent_compute_api_SubscriptionCreationMessage"] = None
@@ -19072,14 +19614,16 @@ class persistent_compute_api_SubscriptionOptions(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'min_delay': ConjureFieldDefinition('minDelay', persistent_compute_api_Milliseconds),
-            'allow_appends': ConjureFieldDefinition('allowAppends', OptionalTypeWrapper[bool])
+            'allow_appends': ConjureFieldDefinition('allowAppends', OptionalTypeWrapper[bool]),
+            'result_configuration': ConjureFieldDefinition('resultConfiguration', OptionalTypeWrapper[persistent_compute_api_ResultConfiguration])
         }
 
-    __slots__: List[str] = ['_min_delay', '_allow_appends']
+    __slots__: List[str] = ['_min_delay', '_allow_appends', '_result_configuration']
 
-    def __init__(self, min_delay: int, allow_appends: Optional[bool] = None) -> None:
+    def __init__(self, min_delay: int, allow_appends: Optional[bool] = None, result_configuration: Optional["persistent_compute_api_ResultConfiguration"] = None) -> None:
         self._min_delay = min_delay
         self._allow_appends = allow_appends
+        self._result_configuration = result_configuration
 
     @builtins.property
     def min_delay(self) -> int:
@@ -19099,6 +19643,13 @@ implement support.
         """
         return self._allow_appends
 
+    @builtins.property
+    def result_configuration(self) -> Optional["persistent_compute_api_ResultConfiguration"]:
+        """Defines the results that are sent for this subscription. If not set, falls back to the behavior 
+defined by `allowAppends`.
+        """
+        return self._result_configuration
+
 
 persistent_compute_api_SubscriptionOptions.__name__ = "SubscriptionOptions"
 persistent_compute_api_SubscriptionOptions.__qualname__ = "SubscriptionOptions"
@@ -19260,6 +19811,24 @@ persistent_compute_api_SubscriptionUpdateMessage.__qualname__ = "SubscriptionUpd
 persistent_compute_api_SubscriptionUpdateMessage.__module__ = "nominal_api.persistent_compute_api"
 
 
+class persistent_compute_api_UnavailableResultConfigurationReason(ConjureEnumType):
+
+    APPENDS_NOT_SUPPORTED_FOR_COMPUTE = 'APPENDS_NOT_SUPPORTED_FOR_COMPUTE'
+    '''APPENDS_NOT_SUPPORTED_FOR_COMPUTE'''
+    TOO_MANY_POINTS_FOR_UNDECIMATED_APPENDS = 'TOO_MANY_POINTS_FOR_UNDECIMATED_APPENDS'
+    '''TOO_MANY_POINTS_FOR_UNDECIMATED_APPENDS'''
+    UNKNOWN = 'UNKNOWN'
+    '''UNKNOWN'''
+
+    def __reduce_ex__(self, proto):
+        return self.__class__, (self.name,)
+
+
+persistent_compute_api_UnavailableResultConfigurationReason.__name__ = "UnavailableResultConfigurationReason"
+persistent_compute_api_UnavailableResultConfigurationReason.__qualname__ = "UnavailableResultConfigurationReason"
+persistent_compute_api_UnavailableResultConfigurationReason.__module__ = "nominal_api.persistent_compute_api"
+
+
 class scout_InternalVersioningService(Service):
     """These endpoints are not intended to be used directly by clients, since
 they require saving resource-specific state associated with new commits.
@@ -24657,18 +25226,20 @@ class scout_catalog_AddFileToDataset(ConjureBeanType):
             'timestamp_metadata': ConjureFieldDefinition('timestampMetadata', OptionalTypeWrapper[scout_catalog_TimestampMetadata]),
             'ingest_tag_metadata': ConjureFieldDefinition('ingestTagMetadata', OptionalTypeWrapper[scout_catalog_IngestTagMetadata]),
             'origin_file_handles': ConjureFieldDefinition('originFileHandles', OptionalTypeWrapper[List[scout_catalog_S3Handle]]),
-            'ingest_job_rid': ConjureFieldDefinition('ingestJobRid', OptionalTypeWrapper[ingest_api_IngestJobRid])
+            'ingest_job_rid': ConjureFieldDefinition('ingestJobRid', OptionalTypeWrapper[ingest_api_IngestJobRid]),
+            'metadata': ConjureFieldDefinition('metadata', OptionalTypeWrapper[scout_catalog_DatasetFileMetadata])
         }
 
-    __slots__: List[str] = ['_handle', '_file_size', '_timestamp_metadata', '_ingest_tag_metadata', '_origin_file_handles', '_ingest_job_rid']
+    __slots__: List[str] = ['_handle', '_file_size', '_timestamp_metadata', '_ingest_tag_metadata', '_origin_file_handles', '_ingest_job_rid', '_metadata']
 
-    def __init__(self, file_size: int, handle: "scout_catalog_Handle", ingest_job_rid: Optional[str] = None, ingest_tag_metadata: Optional["scout_catalog_IngestTagMetadata"] = None, origin_file_handles: Optional[List["scout_catalog_S3Handle"]] = None, timestamp_metadata: Optional["scout_catalog_TimestampMetadata"] = None) -> None:
+    def __init__(self, file_size: int, handle: "scout_catalog_Handle", ingest_job_rid: Optional[str] = None, ingest_tag_metadata: Optional["scout_catalog_IngestTagMetadata"] = None, metadata: Optional["scout_catalog_DatasetFileMetadata"] = None, origin_file_handles: Optional[List["scout_catalog_S3Handle"]] = None, timestamp_metadata: Optional["scout_catalog_TimestampMetadata"] = None) -> None:
         self._handle = handle
         self._file_size = file_size
         self._timestamp_metadata = timestamp_metadata
         self._ingest_tag_metadata = ingest_tag_metadata
         self._origin_file_handles = origin_file_handles
         self._ingest_job_rid = ingest_job_rid
+        self._metadata = metadata
 
     @builtins.property
     def handle(self) -> "scout_catalog_Handle":
@@ -24696,6 +25267,12 @@ class scout_catalog_AddFileToDataset(ConjureBeanType):
     def ingest_job_rid(self) -> Optional[str]:
         return self._ingest_job_rid
 
+    @builtins.property
+    def metadata(self) -> Optional["scout_catalog_DatasetFileMetadata"]:
+        """File-type-specific metadata. For video files, contains timestamp manifest.
+        """
+        return self._metadata
+
 
 scout_catalog_AddFileToDataset.__name__ = "AddFileToDataset"
 scout_catalog_AddFileToDataset.__qualname__ = "AddFileToDataset"
@@ -25932,12 +26509,13 @@ class scout_catalog_DatasetFile(ConjureBeanType):
             'ingest_tag_metadata': ConjureFieldDefinition('ingestTagMetadata', OptionalTypeWrapper[scout_catalog_IngestTagMetadata]),
             'origin_file_paths': ConjureFieldDefinition('originFilePaths', OptionalTypeWrapper[List[str]]),
             'ingest_job_rid': ConjureFieldDefinition('ingestJobRid', OptionalTypeWrapper[ingest_api_IngestJobRid]),
-            'deleted_at': ConjureFieldDefinition('deletedAt', OptionalTypeWrapper[str])
+            'deleted_at': ConjureFieldDefinition('deletedAt', OptionalTypeWrapper[str]),
+            'metadata': ConjureFieldDefinition('metadata', OptionalTypeWrapper[scout_catalog_DatasetFileMetadata])
         }
 
-    __slots__: List[str] = ['_id', '_dataset_rid', '_name', '_handle', '_bounds', '_uploaded_at', '_ingested_at', '_ingest_status', '_timestamp_metadata', '_ingest_tag_metadata', '_origin_file_paths', '_ingest_job_rid', '_deleted_at']
+    __slots__: List[str] = ['_id', '_dataset_rid', '_name', '_handle', '_bounds', '_uploaded_at', '_ingested_at', '_ingest_status', '_timestamp_metadata', '_ingest_tag_metadata', '_origin_file_paths', '_ingest_job_rid', '_deleted_at', '_metadata']
 
-    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, deleted_at: Optional[str] = None, ingest_job_rid: Optional[str] = None, ingest_tag_metadata: Optional["scout_catalog_IngestTagMetadata"] = None, ingested_at: Optional[str] = None, origin_file_paths: Optional[List[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, deleted_at: Optional[str] = None, ingest_job_rid: Optional[str] = None, ingest_tag_metadata: Optional["scout_catalog_IngestTagMetadata"] = None, ingested_at: Optional[str] = None, metadata: Optional["scout_catalog_DatasetFileMetadata"] = None, origin_file_paths: Optional[List[str]] = None, timestamp_metadata: Optional["scout_catalog_TimestampMetadata"] = None) -> None:
         self._id = id
         self._dataset_rid = dataset_rid
         self._name = name
@@ -25951,6 +26529,7 @@ class scout_catalog_DatasetFile(ConjureBeanType):
         self._origin_file_paths = origin_file_paths
         self._ingest_job_rid = ingest_job_rid
         self._deleted_at = deleted_at
+        self._metadata = metadata
 
     @builtins.property
     def id(self) -> str:
@@ -26011,12 +26590,76 @@ ingested for any reason or is still being processed, then this value will be emp
         """
         return self._deleted_at
 
+    @builtins.property
+    def metadata(self) -> Optional["scout_catalog_DatasetFileMetadata"]:
+        """File-type-specific metadata. For video files, contains timestamp manifest and segment metadata.
+        """
+        return self._metadata
+
 
 scout_catalog_DatasetFile.__name__ = "DatasetFile"
 scout_catalog_DatasetFile.__qualname__ = "DatasetFile"
 scout_catalog_DatasetFile.__module__ = "nominal_api.scout_catalog"
 
 
+class scout_catalog_DatasetFileMetadata(ConjureUnionType):
+    """Metadata specific to different file types stored in datasets.
+    """
+    _video: Optional["datasource_VideoFileMetadata"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'video': ConjureFieldDefinition('video', datasource_VideoFileMetadata)
+        }
+
+    def __init__(
+            self,
+            video: Optional["datasource_VideoFileMetadata"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (video is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if video is not None:
+                self._video = video
+                self._type = 'video'
+
+        elif type_of_union == 'video':
+            if video is None:
+                raise ValueError('a union value must not be None')
+            self._video = video
+            self._type = 'video'
+
+    @builtins.property
+    def video(self) -> Optional["datasource_VideoFileMetadata"]:
+        return self._video
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_catalog_DatasetFileMetadataVisitor):
+            raise ValueError('{} is not an instance of scout_catalog_DatasetFileMetadataVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'video' and self.video is not None:
+            return visitor._video(self.video)
+
+
+scout_catalog_DatasetFileMetadata.__name__ = "DatasetFileMetadata"
+scout_catalog_DatasetFileMetadata.__qualname__ = "DatasetFileMetadata"
+scout_catalog_DatasetFileMetadata.__module__ = "nominal_api.scout_catalog"
+
+
+class scout_catalog_DatasetFileMetadataVisitor:
+
+    @abstractmethod
+    def _video(self, video: "datasource_VideoFileMetadata") -> Any:
+        pass
+
+
+scout_catalog_DatasetFileMetadataVisitor.__name__ = "DatasetFileMetadataVisitor"
+scout_catalog_DatasetFileMetadataVisitor.__qualname__ = "DatasetFileMetadataVisitor"
+scout_catalog_DatasetFileMetadataVisitor.__module__ = "nominal_api.scout_catalog"
+
+
 class scout_catalog_DatasetFileSortField(ConjureEnumType):
 
     UPLOADED_AT = 'UPLOADED_AT'
@@ -26547,6 +27190,10 @@ class scout_catalog_IngestStatus(ConjureEnumType):
     '''COMPLETED'''
     FAILED = 'FAILED'
     '''FAILED'''
+    DELETION_IN_PROGRESS = 'DELETION_IN_PROGRESS'
+    '''DELETION_IN_PROGRESS'''
+    DELETED = 'DELETED'
+    '''DELETED'''
     UNKNOWN = 'UNKNOWN'
     '''UNKNOWN'''
 
@@ -44057,62 +44704,6 @@ scout_compute_api_BucketedEnumPlot.__qualname__ = "BucketedEnumPlot"
 scout_compute_api_BucketedEnumPlot.__module__ = "nominal_api.scout_compute_api"
 
 
-class scout_compute_api_BucketedGeoPlot(ConjureUnionType):
-    _time_based: Optional["scout_compute_api_TimeBucketedGeoPlot"] = None
-
-    @builtins.classmethod
-    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'time_based': ConjureFieldDefinition('timeBased', scout_compute_api_TimeBucketedGeoPlot)
-        }
-
-    def __init__(
-            self,
-            time_based: Optional["scout_compute_api_TimeBucketedGeoPlot"] = None,
-            type_of_union: Optional[str] = None
-            ) -> None:
-        if type_of_union is None:
-            if (time_based is not None) != 1:
-                raise ValueError('a union must contain a single member')
-
-            if time_based is not None:
-                self._time_based = time_based
-                self._type = 'timeBased'
-
-        elif type_of_union == 'timeBased':
-            if time_based is None:
-                raise ValueError('a union value must not be None')
-            self._time_based = time_based
-            self._type = 'timeBased'
-
-    @builtins.property
-    def time_based(self) -> Optional["scout_compute_api_TimeBucketedGeoPlot"]:
-        return self._time_based
-
-    def accept(self, visitor) -> Any:
-        if not isinstance(visitor, scout_compute_api_BucketedGeoPlotVisitor):
-            raise ValueError('{} is not an instance of scout_compute_api_BucketedGeoPlotVisitor'.format(visitor.__class__.__name__))
-        if self._type == 'timeBased' and self.time_based is not None:
-            return visitor._time_based(self.time_based)
-
-
-scout_compute_api_BucketedGeoPlot.__name__ = "BucketedGeoPlot"
-scout_compute_api_BucketedGeoPlot.__qualname__ = "BucketedGeoPlot"
-scout_compute_api_BucketedGeoPlot.__module__ = "nominal_api.scout_compute_api"
-
-
-class scout_compute_api_BucketedGeoPlotVisitor:
-
-    @abstractmethod
-    def _time_based(self, time_based: "scout_compute_api_TimeBucketedGeoPlot") -> Any:
-        pass
-
-
-scout_compute_api_BucketedGeoPlotVisitor.__name__ = "BucketedGeoPlotVisitor"
-scout_compute_api_BucketedGeoPlotVisitor.__qualname__ = "BucketedGeoPlotVisitor"
-scout_compute_api_BucketedGeoPlotVisitor.__module__ = "nominal_api.scout_compute_api"
-
-
 class scout_compute_api_BucketedNumericArrayPlot(ConjureBeanType):
     """The array is flattened out into a an arrow stream of bucketed primitive results, with an extra column to
 indicate the index of the array that the bucket corresponds to.
@@ -44810,7 +45401,6 @@ class scout_compute_api_ComputableNode(ConjureUnionType):
     _frequency: Optional["scout_compute_api_FrequencyDomain"] = None
     _frequency_v2: Optional["scout_compute_api_FrequencyDomainV2"] = None
     _histogram: Optional["scout_compute_api_Histogram"] = None
-    _geo: Optional["scout_compute_api_SummarizeGeo"] = None
     _curve: Optional["scout_compute_api_CurveFit"] = None
 
     @builtins.classmethod
@@ -44824,7 +45414,6 @@ class scout_compute_api_ComputableNode(ConjureUnionType):
             'frequency': ConjureFieldDefinition('frequency', scout_compute_api_FrequencyDomain),
             'frequency_v2': ConjureFieldDefinition('frequencyV2', scout_compute_api_FrequencyDomainV2),
             'histogram': ConjureFieldDefinition('histogram', scout_compute_api_Histogram),
-            'geo': ConjureFieldDefinition('geo', scout_compute_api_SummarizeGeo),
             'curve': ConjureFieldDefinition('curve', scout_compute_api_CurveFit)
         }
 
@@ -44838,12 +45427,11 @@ class scout_compute_api_ComputableNode(ConjureUnionType):
             frequency: Optional["scout_compute_api_FrequencyDomain"] = None,
             frequency_v2: Optional["scout_compute_api_FrequencyDomainV2"] = None,
             histogram: Optional["scout_compute_api_Histogram"] = None,
-            geo: Optional["scout_compute_api_SummarizeGeo"] = None,
             curve: Optional["scout_compute_api_CurveFit"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (ranges is not None) + (series is not None) + (value is not None) + (cartesian is not None) + (cartesian3d is not None) + (frequency is not None) + (frequency_v2 is not None) + (histogram is not None) + (geo is not None) + (curve is not None) != 1:
+            if (ranges is not None) + (series is not None) + (value is not None) + (cartesian is not None) + (cartesian3d is not None) + (frequency is not None) + (frequency_v2 is not None) + (histogram is not None) + (curve is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if ranges is not None:
@@ -44870,9 +45458,6 @@ class scout_compute_api_ComputableNode(ConjureUnionType):
             if histogram is not None:
                 self._histogram = histogram
                 self._type = 'histogram'
-            if geo is not None:
-                self._geo = geo
-                self._type = 'geo'
             if curve is not None:
                 self._curve = curve
                 self._type = 'curve'
@@ -44917,11 +45502,6 @@ class scout_compute_api_ComputableNode(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._histogram = histogram
             self._type = 'histogram'
-        elif type_of_union == 'geo':
-            if geo is None:
-                raise ValueError('a union value must not be None')
-            self._geo = geo
-            self._type = 'geo'
         elif type_of_union == 'curve':
             if curve is None:
                 raise ValueError('a union value must not be None')
@@ -44960,10 +45540,6 @@ class scout_compute_api_ComputableNode(ConjureUnionType):
     def histogram(self) -> Optional["scout_compute_api_Histogram"]:
         return self._histogram
 
-    @builtins.property
-    def geo(self) -> Optional["scout_compute_api_SummarizeGeo"]:
-        return self._geo
-
     @builtins.property
     def curve(self) -> Optional["scout_compute_api_CurveFit"]:
         return self._curve
@@ -44987,8 +45563,6 @@ class scout_compute_api_ComputableNode(ConjureUnionType):
             return visitor._frequency_v2(self.frequency_v2)
         if self._type == 'histogram' and self.histogram is not None:
             return visitor._histogram(self.histogram)
-        if self._type == 'geo' and self.geo is not None:
-            return visitor._geo(self.geo)
         if self._type == 'curve' and self.curve is not None:
             return visitor._curve(self.curve)
 
@@ -45032,10 +45606,6 @@ class scout_compute_api_ComputableNodeVisitor:
     def _histogram(self, histogram: "scout_compute_api_Histogram") -> Any:
         pass
 
-    @abstractmethod
-    def _geo(self, geo: "scout_compute_api_SummarizeGeo") -> Any:
-        pass
-
     @abstractmethod
     def _curve(self, curve: "scout_compute_api_CurveFit") -> Any:
         pass
@@ -45351,7 +45921,6 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
     _cartesian: Optional["scout_compute_api_CartesianPlot"] = None
     _bucketed_cartesian: Optional["scout_compute_api_BucketedCartesianPlot"] = None
     _bucketed_cartesian3d: Optional["scout_compute_api_BucketedCartesian3dPlot"] = None
-    _bucketed_geo: Optional["scout_compute_api_BucketedGeoPlot"] = None
     _frequency_domain: Optional["scout_compute_api_FrequencyDomainPlot"] = None
     _frequency_domain_v2: Optional["scout_compute_api_FrequencyDomainPlotV2"] = None
     _numeric_histogram: Optional["scout_compute_api_NumericHistogramPlot"] = None
@@ -45384,7 +45953,6 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
             'cartesian': ConjureFieldDefinition('cartesian', scout_compute_api_CartesianPlot),
             'bucketed_cartesian': ConjureFieldDefinition('bucketedCartesian', scout_compute_api_BucketedCartesianPlot),
             'bucketed_cartesian3d': ConjureFieldDefinition('bucketedCartesian3d', scout_compute_api_BucketedCartesian3dPlot),
-            'bucketed_geo': ConjureFieldDefinition('bucketedGeo', scout_compute_api_BucketedGeoPlot),
             'frequency_domain': ConjureFieldDefinition('frequencyDomain', scout_compute_api_FrequencyDomainPlot),
             'frequency_domain_v2': ConjureFieldDefinition('frequencyDomainV2', scout_compute_api_FrequencyDomainPlotV2),
             'numeric_histogram': ConjureFieldDefinition('numericHistogram', scout_compute_api_NumericHistogramPlot),
@@ -45417,7 +45985,6 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
             cartesian: Optional["scout_compute_api_CartesianPlot"] = None,
             bucketed_cartesian: Optional["scout_compute_api_BucketedCartesianPlot"] = None,
             bucketed_cartesian3d: Optional["scout_compute_api_BucketedCartesian3dPlot"] = None,
-            bucketed_geo: Optional["scout_compute_api_BucketedGeoPlot"] = None,
             frequency_domain: Optional["scout_compute_api_FrequencyDomainPlot"] = None,
             frequency_domain_v2: Optional["scout_compute_api_FrequencyDomainPlotV2"] = None,
             numeric_histogram: Optional["scout_compute_api_NumericHistogramPlot"] = None,
@@ -45430,7 +45997,7 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (range is not None) + (ranges_summary is not None) + (range_value is not None) + (numeric is not None) + (bucketed_numeric is not None) + (numeric_point is not None) + (single_point is not None) + (arrow_numeric is not None) + (arrow_bucketed_numeric is not None) + (enum is not None) + (enum_point is not None) + (bucketed_enum is not None) + (arrow_enum is not None) + (arrow_bucketed_enum is not None) + (paged_log is not None) + (log_point is not None) + (cartesian is not None) + (bucketed_cartesian is not None) + (bucketed_cartesian3d is not None) + (bucketed_geo is not None) + (frequency_domain is not None) + (frequency_domain_v2 is not None) + (numeric_histogram is not None) + (enum_histogram is not None) + (curve_fit is not None) + (grouped is not None) + (array is not None) + (bucketed_struct is not None) + (full_resolution is not None) != 1:
+            if (range is not None) + (ranges_summary is not None) + (range_value is not None) + (numeric is not None) + (bucketed_numeric is not None) + (numeric_point is not None) + (single_point is not None) + (arrow_numeric is not None) + (arrow_bucketed_numeric is not None) + (enum is not None) + (enum_point is not None) + (bucketed_enum is not None) + (arrow_enum is not None) + (arrow_bucketed_enum is not None) + (paged_log is not None) + (log_point is not None) + (cartesian is not None) + (bucketed_cartesian is not None) + (bucketed_cartesian3d is not None) + (frequency_domain is not None) + (frequency_domain_v2 is not None) + (numeric_histogram is not None) + (enum_histogram is not None) + (curve_fit is not None) + (grouped is not None) + (array is not None) + (bucketed_struct is not None) + (full_resolution is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if range is not None:
@@ -45490,9 +46057,6 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
             if bucketed_cartesian3d is not None:
                 self._bucketed_cartesian3d = bucketed_cartesian3d
                 self._type = 'bucketedCartesian3d'
-            if bucketed_geo is not None:
-                self._bucketed_geo = bucketed_geo
-                self._type = 'bucketedGeo'
             if frequency_domain is not None:
                 self._frequency_domain = frequency_domain
                 self._type = 'frequencyDomain'
@@ -45616,11 +46180,6 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._bucketed_cartesian3d = bucketed_cartesian3d
             self._type = 'bucketedCartesian3d'
-        elif type_of_union == 'bucketedGeo':
-            if bucketed_geo is None:
-                raise ValueError('a union value must not be None')
-            self._bucketed_geo = bucketed_geo
-            self._type = 'bucketedGeo'
         elif type_of_union == 'frequencyDomain':
             if frequency_domain is None:
                 raise ValueError('a union value must not be None')
@@ -45743,10 +46302,6 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
     def bucketed_cartesian3d(self) -> Optional["scout_compute_api_BucketedCartesian3dPlot"]:
         return self._bucketed_cartesian3d
 
-    @builtins.property
-    def bucketed_geo(self) -> Optional["scout_compute_api_BucketedGeoPlot"]:
-        return self._bucketed_geo
-
     @builtins.property
     def frequency_domain(self) -> Optional["scout_compute_api_FrequencyDomainPlot"]:
         return self._frequency_domain
@@ -45824,8 +46379,6 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
             return visitor._bucketed_cartesian(self.bucketed_cartesian)
         if self._type == 'bucketedCartesian3d' and self.bucketed_cartesian3d is not None:
             return visitor._bucketed_cartesian3d(self.bucketed_cartesian3d)
-        if self._type == 'bucketedGeo' and self.bucketed_geo is not None:
-            return visitor._bucketed_geo(self.bucketed_geo)
         if self._type == 'frequencyDomain' and self.frequency_domain is not None:
             return visitor._frequency_domain(self.frequency_domain)
         if self._type == 'frequencyDomainV2' and self.frequency_domain_v2 is not None:
@@ -45929,10 +46482,6 @@ class scout_compute_api_ComputeNodeResponseVisitor:
     def _bucketed_cartesian3d(self, bucketed_cartesian3d: "scout_compute_api_BucketedCartesian3dPlot") -> Any:
         pass
 
-    @abstractmethod
-    def _bucketed_geo(self, bucketed_geo: "scout_compute_api_BucketedGeoPlot") -> Any:
-        pass
-
     @abstractmethod
     def _frequency_domain(self, frequency_domain: "scout_compute_api_FrequencyDomainPlot") -> Any:
         pass
@@ -49795,279 +50344,6 @@ scout_compute_api_FunctionVariables.__qualname__ = "FunctionVariables"
 scout_compute_api_FunctionVariables.__module__ = "nominal_api.scout_compute_api"
 
 
-class scout_compute_api_GeoPoint(ConjureUnionType):
-    """Represents a geographic point. Flexible to handle multiple types of geographic coordinate systems.
-    """
-    _lat_long: Optional["scout_compute_api_LatLongPoint"] = None
-
-    @builtins.classmethod
-    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'lat_long': ConjureFieldDefinition('latLong', scout_compute_api_LatLongPoint)
-        }
-
-    def __init__(
-            self,
-            lat_long: Optional["scout_compute_api_LatLongPoint"] = None,
-            type_of_union: Optional[str] = None
-            ) -> None:
-        if type_of_union is None:
-            if (lat_long is not None) != 1:
-                raise ValueError('a union must contain a single member')
-
-            if lat_long is not None:
-                self._lat_long = lat_long
-                self._type = 'latLong'
-
-        elif type_of_union == 'latLong':
-            if lat_long is None:
-                raise ValueError('a union value must not be None')
-            self._lat_long = lat_long
-            self._type = 'latLong'
-
-    @builtins.property
-    def lat_long(self) -> Optional["scout_compute_api_LatLongPoint"]:
-        return self._lat_long
-
-    def accept(self, visitor) -> Any:
-        if not isinstance(visitor, scout_compute_api_GeoPointVisitor):
-            raise ValueError('{} is not an instance of scout_compute_api_GeoPointVisitor'.format(visitor.__class__.__name__))
-        if self._type == 'latLong' and self.lat_long is not None:
-            return visitor._lat_long(self.lat_long)
-
-
-scout_compute_api_GeoPoint.__name__ = "GeoPoint"
-scout_compute_api_GeoPoint.__qualname__ = "GeoPoint"
-scout_compute_api_GeoPoint.__module__ = "nominal_api.scout_compute_api"
-
-
-class scout_compute_api_GeoPointVisitor:
-
-    @abstractmethod
-    def _lat_long(self, lat_long: "scout_compute_api_LatLongPoint") -> Any:
-        pass
-
-
-scout_compute_api_GeoPointVisitor.__name__ = "GeoPointVisitor"
-scout_compute_api_GeoPointVisitor.__qualname__ = "GeoPointVisitor"
-scout_compute_api_GeoPointVisitor.__module__ = "nominal_api.scout_compute_api"
-
-
-class scout_compute_api_GeoPointWithTimestamp(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'timestamp': ConjureFieldDefinition('timestamp', api_Timestamp),
-            'value': ConjureFieldDefinition('value', scout_compute_api_GeoPoint)
-        }
-
-    __slots__: List[str] = ['_timestamp', '_value']
-
-    def __init__(self, timestamp: "api_Timestamp", value: "scout_compute_api_GeoPoint") -> None:
-        self._timestamp = timestamp
-        self._value = value
-
-    @builtins.property
-    def timestamp(self) -> "api_Timestamp":
-        return self._timestamp
-
-    @builtins.property
-    def value(self) -> "scout_compute_api_GeoPoint":
-        return self._value
-
-
-scout_compute_api_GeoPointWithTimestamp.__name__ = "GeoPointWithTimestamp"
-scout_compute_api_GeoPointWithTimestamp.__qualname__ = "GeoPointWithTimestamp"
-scout_compute_api_GeoPointWithTimestamp.__module__ = "nominal_api.scout_compute_api"
-
-
-class scout_compute_api_GeoSeries(ConjureUnionType):
-    _lat_long_geo_node: Optional["scout_compute_api_LatLongGeo"] = None
-
-    @builtins.classmethod
-    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'lat_long_geo_node': ConjureFieldDefinition('latLongGeoNode', scout_compute_api_LatLongGeo)
-        }
-
-    def __init__(
-            self,
-            lat_long_geo_node: Optional["scout_compute_api_LatLongGeo"] = None,
-            type_of_union: Optional[str] = None
-            ) -> None:
-        if type_of_union is None:
-            if (lat_long_geo_node is not None) != 1:
-                raise ValueError('a union must contain a single member')
-
-            if lat_long_geo_node is not None:
-                self._lat_long_geo_node = lat_long_geo_node
-                self._type = 'latLongGeoNode'
-
-        elif type_of_union == 'latLongGeoNode':
-            if lat_long_geo_node is None:
-                raise ValueError('a union value must not be None')
-            self._lat_long_geo_node = lat_long_geo_node
-            self._type = 'latLongGeoNode'
-
-    @builtins.property
-    def lat_long_geo_node(self) -> Optional["scout_compute_api_LatLongGeo"]:
-        return self._lat_long_geo_node
-
-    def accept(self, visitor) -> Any:
-        if not isinstance(visitor, scout_compute_api_GeoSeriesVisitor):
-            raise ValueError('{} is not an instance of scout_compute_api_GeoSeriesVisitor'.format(visitor.__class__.__name__))
-        if self._type == 'latLongGeoNode' and self.lat_long_geo_node is not None:
-            return visitor._lat_long_geo_node(self.lat_long_geo_node)
-
-
-scout_compute_api_GeoSeries.__name__ = "GeoSeries"
-scout_compute_api_GeoSeries.__qualname__ = "GeoSeries"
-scout_compute_api_GeoSeries.__module__ = "nominal_api.scout_compute_api"
-
-
-class scout_compute_api_GeoSeriesVisitor:
-
-    @abstractmethod
-    def _lat_long_geo_node(self, lat_long_geo_node: "scout_compute_api_LatLongGeo") -> Any:
-        pass
-
-
-scout_compute_api_GeoSeriesVisitor.__name__ = "GeoSeriesVisitor"
-scout_compute_api_GeoSeriesVisitor.__qualname__ = "GeoSeriesVisitor"
-scout_compute_api_GeoSeriesVisitor.__module__ = "nominal_api.scout_compute_api"
-
-
-class scout_compute_api_GeoSummaryStrategy(ConjureUnionType):
-    _temporal: Optional["scout_compute_api_GeoTemporalSummary"] = None
-
-    @builtins.classmethod
-    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'temporal': ConjureFieldDefinition('temporal', scout_compute_api_GeoTemporalSummary)
-        }
-
-    def __init__(
-            self,
-            temporal: Optional["scout_compute_api_GeoTemporalSummary"] = None,
-            type_of_union: Optional[str] = None
-            ) -> None:
-        if type_of_union is None:
-            if (temporal is not None) != 1:
-                raise ValueError('a union must contain a single member')
-
-            if temporal is not None:
-                self._temporal = temporal
-                self._type = 'temporal'
-
-        elif type_of_union == 'temporal':
-            if temporal is None:
-                raise ValueError('a union value must not be None')
-            self._temporal = temporal
-            self._type = 'temporal'
-
-    @builtins.property
-    def temporal(self) -> Optional["scout_compute_api_GeoTemporalSummary"]:
-        return self._temporal
-
-    def accept(self, visitor) -> Any:
-        if not isinstance(visitor, scout_compute_api_GeoSummaryStrategyVisitor):
-            raise ValueError('{} is not an instance of scout_compute_api_GeoSummaryStrategyVisitor'.format(visitor.__class__.__name__))
-        if self._type == 'temporal' and self.temporal is not None:
-            return visitor._temporal(self.temporal)
-
-
-scout_compute_api_GeoSummaryStrategy.__name__ = "GeoSummaryStrategy"
-scout_compute_api_GeoSummaryStrategy.__qualname__ = "GeoSummaryStrategy"
-scout_compute_api_GeoSummaryStrategy.__module__ = "nominal_api.scout_compute_api"
-
-
-class scout_compute_api_GeoSummaryStrategyVisitor:
-
-    @abstractmethod
-    def _temporal(self, temporal: "scout_compute_api_GeoTemporalSummary") -> Any:
-        pass
-
-
-scout_compute_api_GeoSummaryStrategyVisitor.__name__ = "GeoSummaryStrategyVisitor"
-scout_compute_api_GeoSummaryStrategyVisitor.__qualname__ = "GeoSummaryStrategyVisitor"
-scout_compute_api_GeoSummaryStrategyVisitor.__module__ = "nominal_api.scout_compute_api"
-
-
-class scout_compute_api_GeoTemporalSummary(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:
-        return self._resolution
-
-
-scout_compute_api_GeoTemporalSummary.__name__ = "GeoTemporalSummary"
-scout_compute_api_GeoTemporalSummary.__qualname__ = "GeoTemporalSummary"
-scout_compute_api_GeoTemporalSummary.__module__ = "nominal_api.scout_compute_api"
-
-
-class scout_compute_api_GeoTimeBucket(ConjureBeanType):
-    """Summary of a time-based bucket of geo points.
-    """
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'mean': ConjureFieldDefinition('mean', scout_compute_api_GeoPoint),
-            'count': ConjureFieldDefinition('count', int),
-            'first_point': ConjureFieldDefinition('firstPoint', scout_compute_api_GeoPointWithTimestamp),
-            'last_point': ConjureFieldDefinition('lastPoint', OptionalTypeWrapper[scout_compute_api_GeoPointWithTimestamp])
-        }
-
-    __slots__: List[str] = ['_mean', '_count', '_first_point', '_last_point']
-
-    def __init__(self, count: int, first_point: "scout_compute_api_GeoPointWithTimestamp", mean: "scout_compute_api_GeoPoint", last_point: Optional["scout_compute_api_GeoPointWithTimestamp"] = None) -> None:
-        self._mean = mean
-        self._count = count
-        self._first_point = first_point
-        self._last_point = last_point
-
-    @builtins.property
-    def mean(self) -> "scout_compute_api_GeoPoint":
-        """The mean value of the GeoPoints in the bucket.
-        """
-        return self._mean
-
-    @builtins.property
-    def count(self) -> int:
-        """The number of GeoPoints in the bucket.
-        """
-        return self._count
-
-    @builtins.property
-    def first_point(self) -> "scout_compute_api_GeoPointWithTimestamp":
-        """The first GeoPoint in the bucket.
-        """
-        return self._first_point
-
-    @builtins.property
-    def last_point(self) -> Optional["scout_compute_api_GeoPointWithTimestamp"]:
-        """The last GeoPoint in the bucket. Will be empty if the bucket only has a single point.
-        """
-        return self._last_point
-
-
-scout_compute_api_GeoTimeBucket.__name__ = "GeoTimeBucket"
-scout_compute_api_GeoTimeBucket.__qualname__ = "GeoTimeBucket"
-scout_compute_api_GeoTimeBucket.__module__ = "nominal_api.scout_compute_api"
-
-
 class scout_compute_api_GroupedComputeNodeResponse(ConjureBeanType):
 
     @builtins.classmethod
@@ -50537,75 +50813,6 @@ scout_compute_api_IntersectRanges.__qualname__ = "IntersectRanges"
 scout_compute_api_IntersectRanges.__module__ = "nominal_api.scout_compute_api"
 
 
-class scout_compute_api_LatLongBounds(ConjureBeanType):
-    """The bounds of a lat long geographic area. Represented by the southwest and northeast corners 
-of a rectangle, inclusive.
-    """
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'south_west': ConjureFieldDefinition('southWest', scout_compute_api_LatLongPoint),
-            'north_east': ConjureFieldDefinition('northEast', scout_compute_api_LatLongPoint)
-        }
-
-    __slots__: List[str] = ['_south_west', '_north_east']
-
-    def __init__(self, north_east: "scout_compute_api_LatLongPoint", south_west: "scout_compute_api_LatLongPoint") -> None:
-        self._south_west = south_west
-        self._north_east = north_east
-
-    @builtins.property
-    def south_west(self) -> "scout_compute_api_LatLongPoint":
-        return self._south_west
-
-    @builtins.property
-    def north_east(self) -> "scout_compute_api_LatLongPoint":
-        return self._north_east
-
-
-scout_compute_api_LatLongBounds.__name__ = "LatLongBounds"
-scout_compute_api_LatLongBounds.__qualname__ = "LatLongBounds"
-scout_compute_api_LatLongBounds.__module__ = "nominal_api.scout_compute_api"
-
-
-class scout_compute_api_LatLongGeo(ConjureBeanType):
-    """A geo node derived from a lat and long series.
-    """
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'latitude': ConjureFieldDefinition('latitude', scout_compute_api_NumericSeries),
-            'longitude': ConjureFieldDefinition('longitude', scout_compute_api_NumericSeries),
-            'bounds': ConjureFieldDefinition('bounds', OptionalTypeWrapper[scout_compute_api_LatLongBounds])
-        }
-
-    __slots__: List[str] = ['_latitude', '_longitude', '_bounds']
-
-    def __init__(self, latitude: "scout_compute_api_NumericSeries", longitude: "scout_compute_api_NumericSeries", bounds: Optional["scout_compute_api_LatLongBounds"] = None) -> None:
-        self._latitude = latitude
-        self._longitude = longitude
-        self._bounds = bounds
-
-    @builtins.property
-    def latitude(self) -> "scout_compute_api_NumericSeries":
-        return self._latitude
-
-    @builtins.property
-    def longitude(self) -> "scout_compute_api_NumericSeries":
-        return self._longitude
-
-    @builtins.property
-    def bounds(self) -> Optional["scout_compute_api_LatLongBounds"]:
-        return self._bounds
-
-
-scout_compute_api_LatLongGeo.__name__ = "LatLongGeo"
-scout_compute_api_LatLongGeo.__qualname__ = "LatLongGeo"
-scout_compute_api_LatLongGeo.__module__ = "nominal_api.scout_compute_api"
-
-
 class scout_compute_api_LatLongPoint(ConjureBeanType):
 
     @builtins.classmethod
@@ -57758,35 +57965,6 @@ scout_compute_api_SummarizeCartesian3d.__qualname__ = "SummarizeCartesian3d"
 scout_compute_api_SummarizeCartesian3d.__module__ = "nominal_api.scout_compute_api"
 
 
-class scout_compute_api_SummarizeGeo(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'input': ConjureFieldDefinition('input', scout_compute_api_GeoSeries),
-            'summary_strategy': ConjureFieldDefinition('summaryStrategy', scout_compute_api_GeoSummaryStrategy)
-        }
-
-    __slots__: List[str] = ['_input', '_summary_strategy']
-
-    def __init__(self, input: "scout_compute_api_GeoSeries", summary_strategy: "scout_compute_api_GeoSummaryStrategy") -> None:
-        self._input = input
-        self._summary_strategy = summary_strategy
-
-    @builtins.property
-    def input(self) -> "scout_compute_api_GeoSeries":
-        return self._input
-
-    @builtins.property
-    def summary_strategy(self) -> "scout_compute_api_GeoSummaryStrategy":
-        return self._summary_strategy
-
-
-scout_compute_api_SummarizeGeo.__name__ = "SummarizeGeo"
-scout_compute_api_SummarizeGeo.__qualname__ = "SummarizeGeo"
-scout_compute_api_SummarizeGeo.__module__ = "nominal_api.scout_compute_api"
-
-
 class scout_compute_api_SummarizeRanges(ConjureBeanType):
 
     @builtins.classmethod
@@ -58247,37 +58425,6 @@ scout_compute_api_ThresholdingRanges.__qualname__ = "ThresholdingRanges"
 scout_compute_api_ThresholdingRanges.__module__ = "nominal_api.scout_compute_api"
 
 
-class scout_compute_api_TimeBucketedGeoPlot(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'timestamps': ConjureFieldDefinition('timestamps', List[api_Timestamp]),
-            'buckets': ConjureFieldDefinition('buckets', List[scout_compute_api_GeoTimeBucket])
-        }
-
-    __slots__: List[str] = ['_timestamps', '_buckets']
-
-    def __init__(self, buckets: List["scout_compute_api_GeoTimeBucket"], timestamps: List["api_Timestamp"]) -> None:
-        self._timestamps = timestamps
-        self._buckets = buckets
-
-    @builtins.property
-    def timestamps(self) -> List["api_Timestamp"]:
-        """The end of the bucket, exclusive.
-        """
-        return self._timestamps
-
-    @builtins.property
-    def buckets(self) -> List["scout_compute_api_GeoTimeBucket"]:
-        return self._buckets
-
-
-scout_compute_api_TimeBucketedGeoPlot.__name__ = "TimeBucketedGeoPlot"
-scout_compute_api_TimeBucketedGeoPlot.__qualname__ = "TimeBucketedGeoPlot"
-scout_compute_api_TimeBucketedGeoPlot.__module__ = "nominal_api.scout_compute_api"
-
-
 class scout_compute_api_TimeDifferenceSeries(ConjureBeanType):
     """Outputs a new series where each value is the difference between the time of the current and previous points.
     """
@@ -63842,141 +63989,6 @@ scout_compute_resolved_api_FrequencyDomainNodeV2Visitor.__qualname__ = "Frequenc
 scout_compute_resolved_api_FrequencyDomainNodeV2Visitor.__module__ = "nominal_api.scout_compute_resolved_api"
 
 
-class scout_compute_resolved_api_GeoNode(ConjureUnionType):
-    _lat_long_geo_node: Optional["scout_compute_resolved_api_LatLongGeoNode"] = None
-
-    @builtins.classmethod
-    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'lat_long_geo_node': ConjureFieldDefinition('latLongGeoNode', scout_compute_resolved_api_LatLongGeoNode)
-        }
-
-    def __init__(
-            self,
-            lat_long_geo_node: Optional["scout_compute_resolved_api_LatLongGeoNode"] = None,
-            type_of_union: Optional[str] = None
-            ) -> None:
-        if type_of_union is None:
-            if (lat_long_geo_node is not None) != 1:
-                raise ValueError('a union must contain a single member')
-
-            if lat_long_geo_node is not None:
-                self._lat_long_geo_node = lat_long_geo_node
-                self._type = 'latLongGeoNode'
-
-        elif type_of_union == 'latLongGeoNode':
-            if lat_long_geo_node is None:
-                raise ValueError('a union value must not be None')
-            self._lat_long_geo_node = lat_long_geo_node
-            self._type = 'latLongGeoNode'
-
-    @builtins.property
-    def lat_long_geo_node(self) -> Optional["scout_compute_resolved_api_LatLongGeoNode"]:
-        return self._lat_long_geo_node
-
-    def accept(self, visitor) -> Any:
-        if not isinstance(visitor, scout_compute_resolved_api_GeoNodeVisitor):
-            raise ValueError('{} is not an instance of scout_compute_resolved_api_GeoNodeVisitor'.format(visitor.__class__.__name__))
-        if self._type == 'latLongGeoNode' and self.lat_long_geo_node is not None:
-            return visitor._lat_long_geo_node(self.lat_long_geo_node)
-
-
-scout_compute_resolved_api_GeoNode.__name__ = "GeoNode"
-scout_compute_resolved_api_GeoNode.__qualname__ = "GeoNode"
-scout_compute_resolved_api_GeoNode.__module__ = "nominal_api.scout_compute_resolved_api"
-
-
-class scout_compute_resolved_api_GeoNodeVisitor:
-
-    @abstractmethod
-    def _lat_long_geo_node(self, lat_long_geo_node: "scout_compute_resolved_api_LatLongGeoNode") -> Any:
-        pass
-
-
-scout_compute_resolved_api_GeoNodeVisitor.__name__ = "GeoNodeVisitor"
-scout_compute_resolved_api_GeoNodeVisitor.__qualname__ = "GeoNodeVisitor"
-scout_compute_resolved_api_GeoNodeVisitor.__module__ = "nominal_api.scout_compute_resolved_api"
-
-
-class scout_compute_resolved_api_GeoNodeSummaryStrategy(ConjureUnionType):
-    _temporal: Optional["scout_compute_resolved_api_GeoNodeTemporalSummary"] = None
-
-    @builtins.classmethod
-    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'temporal': ConjureFieldDefinition('temporal', scout_compute_resolved_api_GeoNodeTemporalSummary)
-        }
-
-    def __init__(
-            self,
-            temporal: Optional["scout_compute_resolved_api_GeoNodeTemporalSummary"] = None,
-            type_of_union: Optional[str] = None
-            ) -> None:
-        if type_of_union is None:
-            if (temporal is not None) != 1:
-                raise ValueError('a union must contain a single member')
-
-            if temporal is not None:
-                self._temporal = temporal
-                self._type = 'temporal'
-
-        elif type_of_union == 'temporal':
-            if temporal is None:
-                raise ValueError('a union value must not be None')
-            self._temporal = temporal
-            self._type = 'temporal'
-
-    @builtins.property
-    def temporal(self) -> Optional["scout_compute_resolved_api_GeoNodeTemporalSummary"]:
-        return self._temporal
-
-    def accept(self, visitor) -> Any:
-        if not isinstance(visitor, scout_compute_resolved_api_GeoNodeSummaryStrategyVisitor):
-            raise ValueError('{} is not an instance of scout_compute_resolved_api_GeoNodeSummaryStrategyVisitor'.format(visitor.__class__.__name__))
-        if self._type == 'temporal' and self.temporal is not None:
-            return visitor._temporal(self.temporal)
-
-
-scout_compute_resolved_api_GeoNodeSummaryStrategy.__name__ = "GeoNodeSummaryStrategy"
-scout_compute_resolved_api_GeoNodeSummaryStrategy.__qualname__ = "GeoNodeSummaryStrategy"
-scout_compute_resolved_api_GeoNodeSummaryStrategy.__module__ = "nominal_api.scout_compute_resolved_api"
-
-
-class scout_compute_resolved_api_GeoNodeSummaryStrategyVisitor:
-
-    @abstractmethod
-    def _temporal(self, temporal: "scout_compute_resolved_api_GeoNodeTemporalSummary") -> Any:
-        pass
-
-
-scout_compute_resolved_api_GeoNodeSummaryStrategyVisitor.__name__ = "GeoNodeSummaryStrategyVisitor"
-scout_compute_resolved_api_GeoNodeSummaryStrategyVisitor.__qualname__ = "GeoNodeSummaryStrategyVisitor"
-scout_compute_resolved_api_GeoNodeSummaryStrategyVisitor.__module__ = "nominal_api.scout_compute_resolved_api"
-
-
-class scout_compute_resolved_api_GeoNodeTemporalSummary(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:
-        return self._resolution
-
-
-scout_compute_resolved_api_GeoNodeTemporalSummary.__name__ = "GeoNodeTemporalSummary"
-scout_compute_resolved_api_GeoNodeTemporalSummary.__qualname__ = "GeoNodeTemporalSummary"
-scout_compute_resolved_api_GeoNodeTemporalSummary.__module__ = "nominal_api.scout_compute_resolved_api"
-
-
 class scout_compute_resolved_api_HighPassConfiguration(ConjureBeanType):
 
     @builtins.classmethod
@@ -64191,70 +64203,6 @@ scout_compute_resolved_api_IntersectRangesNode.__qualname__ = "IntersectRangesNo
 scout_compute_resolved_api_IntersectRangesNode.__module__ = "nominal_api.scout_compute_resolved_api"
 
 
-class scout_compute_resolved_api_LatLongBounds(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'south_west': ConjureFieldDefinition('southWest', scout_compute_api_LatLongPoint),
-            'north_east': ConjureFieldDefinition('northEast', scout_compute_api_LatLongPoint)
-        }
-
-    __slots__: List[str] = ['_south_west', '_north_east']
-
-    def __init__(self, north_east: "scout_compute_api_LatLongPoint", south_west: "scout_compute_api_LatLongPoint") -> None:
-        self._south_west = south_west
-        self._north_east = north_east
-
-    @builtins.property
-    def south_west(self) -> "scout_compute_api_LatLongPoint":
-        return self._south_west
-
-    @builtins.property
-    def north_east(self) -> "scout_compute_api_LatLongPoint":
-        return self._north_east
-
-
-scout_compute_resolved_api_LatLongBounds.__name__ = "LatLongBounds"
-scout_compute_resolved_api_LatLongBounds.__qualname__ = "LatLongBounds"
-scout_compute_resolved_api_LatLongBounds.__module__ = "nominal_api.scout_compute_resolved_api"
-
-
-class scout_compute_resolved_api_LatLongGeoNode(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'latitude': ConjureFieldDefinition('latitude', scout_compute_resolved_api_NumericSeriesNode),
-            'longitude': ConjureFieldDefinition('longitude', scout_compute_resolved_api_NumericSeriesNode),
-            'bounds': ConjureFieldDefinition('bounds', OptionalTypeWrapper[scout_compute_resolved_api_LatLongBounds])
-        }
-
-    __slots__: List[str] = ['_latitude', '_longitude', '_bounds']
-
-    def __init__(self, latitude: "scout_compute_resolved_api_NumericSeriesNode", longitude: "scout_compute_resolved_api_NumericSeriesNode", bounds: Optional["scout_compute_resolved_api_LatLongBounds"] = None) -> None:
-        self._latitude = latitude
-        self._longitude = longitude
-        self._bounds = bounds
-
-    @builtins.property
-    def latitude(self) -> "scout_compute_resolved_api_NumericSeriesNode":
-        return self._latitude
-
-    @builtins.property
-    def longitude(self) -> "scout_compute_resolved_api_NumericSeriesNode":
-        return self._longitude
-
-    @builtins.property
-    def bounds(self) -> Optional["scout_compute_resolved_api_LatLongBounds"]:
-        return self._bounds
-
-
-scout_compute_resolved_api_LatLongGeoNode.__name__ = "LatLongGeoNode"
-scout_compute_resolved_api_LatLongGeoNode.__qualname__ = "LatLongGeoNode"
-scout_compute_resolved_api_LatLongGeoNode.__module__ = "nominal_api.scout_compute_resolved_api"
-
-
 class scout_compute_resolved_api_LiteralRange(ConjureBeanType):
 
     @builtins.classmethod
@@ -67054,7 +67002,6 @@ class scout_compute_resolved_api_ResolvedNode(ConjureUnionType):
     _frequency: Optional["scout_compute_resolved_api_FrequencyDomainNode"] = None
     _frequency_v2: Optional["scout_compute_resolved_api_FrequencyDomainNodeV2"] = None
     _histogram: Optional["scout_compute_resolved_api_HistogramNode"] = None
-    _geo: Optional["scout_compute_resolved_api_SummarizeGeoNode"] = None
     _curve: Optional["scout_compute_resolved_api_CurveFitNode"] = None
 
     @builtins.classmethod
@@ -67068,7 +67015,6 @@ class scout_compute_resolved_api_ResolvedNode(ConjureUnionType):
             'frequency': ConjureFieldDefinition('frequency', scout_compute_resolved_api_FrequencyDomainNode),
             'frequency_v2': ConjureFieldDefinition('frequencyV2', scout_compute_resolved_api_FrequencyDomainNodeV2),
             'histogram': ConjureFieldDefinition('histogram', scout_compute_resolved_api_HistogramNode),
-            'geo': ConjureFieldDefinition('geo', scout_compute_resolved_api_SummarizeGeoNode),
             'curve': ConjureFieldDefinition('curve', scout_compute_resolved_api_CurveFitNode)
         }
 
@@ -67082,12 +67028,11 @@ class scout_compute_resolved_api_ResolvedNode(ConjureUnionType):
             frequency: Optional["scout_compute_resolved_api_FrequencyDomainNode"] = None,
             frequency_v2: Optional["scout_compute_resolved_api_FrequencyDomainNodeV2"] = None,
             histogram: Optional["scout_compute_resolved_api_HistogramNode"] = None,
-            geo: Optional["scout_compute_resolved_api_SummarizeGeoNode"] = None,
             curve: Optional["scout_compute_resolved_api_CurveFitNode"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (ranges is not None) + (series is not None) + (value is not None) + (cartesian is not None) + (cartesian3d is not None) + (frequency is not None) + (frequency_v2 is not None) + (histogram is not None) + (geo is not None) + (curve is not None) != 1:
+            if (ranges is not None) + (series is not None) + (value is not None) + (cartesian is not None) + (cartesian3d is not None) + (frequency is not None) + (frequency_v2 is not None) + (histogram is not None) + (curve is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if ranges is not None:
@@ -67114,9 +67059,6 @@ class scout_compute_resolved_api_ResolvedNode(ConjureUnionType):
             if histogram is not None:
                 self._histogram = histogram
                 self._type = 'histogram'
-            if geo is not None:
-                self._geo = geo
-                self._type = 'geo'
             if curve is not None:
                 self._curve = curve
                 self._type = 'curve'
@@ -67161,11 +67103,6 @@ class scout_compute_resolved_api_ResolvedNode(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._histogram = histogram
             self._type = 'histogram'
-        elif type_of_union == 'geo':
-            if geo is None:
-                raise ValueError('a union value must not be None')
-            self._geo = geo
-            self._type = 'geo'
         elif type_of_union == 'curve':
             if curve is None:
                 raise ValueError('a union value must not be None')
@@ -67204,10 +67141,6 @@ class scout_compute_resolved_api_ResolvedNode(ConjureUnionType):
     def histogram(self) -> Optional["scout_compute_resolved_api_HistogramNode"]:
         return self._histogram
 
-    @builtins.property
-    def geo(self) -> Optional["scout_compute_resolved_api_SummarizeGeoNode"]:
-        return self._geo
-
     @builtins.property
     def curve(self) -> Optional["scout_compute_resolved_api_CurveFitNode"]:
         return self._curve
@@ -67231,8 +67164,6 @@ class scout_compute_resolved_api_ResolvedNode(ConjureUnionType):
             return visitor._frequency_v2(self.frequency_v2)
         if self._type == 'histogram' and self.histogram is not None:
             return visitor._histogram(self.histogram)
-        if self._type == 'geo' and self.geo is not None:
-            return visitor._geo(self.geo)
         if self._type == 'curve' and self.curve is not None:
             return visitor._curve(self.curve)
 
@@ -67276,10 +67207,6 @@ class scout_compute_resolved_api_ResolvedNodeVisitor:
     def _histogram(self, histogram: "scout_compute_resolved_api_HistogramNode") -> Any:
         pass
 
-    @abstractmethod
-    def _geo(self, geo: "scout_compute_resolved_api_SummarizeGeoNode") -> Any:
-        pass
-
     @abstractmethod
     def _curve(self, curve: "scout_compute_resolved_api_CurveFitNode") -> Any:
         pass
@@ -68488,35 +68415,6 @@ scout_compute_resolved_api_SummarizeCartesianNode.__qualname__ = "SummarizeCarte
 scout_compute_resolved_api_SummarizeCartesianNode.__module__ = "nominal_api.scout_compute_resolved_api"
 
 
-class scout_compute_resolved_api_SummarizeGeoNode(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'input': ConjureFieldDefinition('input', scout_compute_resolved_api_GeoNode),
-            'summary_strategy': ConjureFieldDefinition('summaryStrategy', scout_compute_resolved_api_GeoNodeSummaryStrategy)
-        }
-
-    __slots__: List[str] = ['_input', '_summary_strategy']
-
-    def __init__(self, input: "scout_compute_resolved_api_GeoNode", summary_strategy: "scout_compute_resolved_api_GeoNodeSummaryStrategy") -> None:
-        self._input = input
-        self._summary_strategy = summary_strategy
-
-    @builtins.property
-    def input(self) -> "scout_compute_resolved_api_GeoNode":
-        return self._input
-
-    @builtins.property
-    def summary_strategy(self) -> "scout_compute_resolved_api_GeoNodeSummaryStrategy":
-        return self._summary_strategy
-
-
-scout_compute_resolved_api_SummarizeGeoNode.__name__ = "SummarizeGeoNode"
-scout_compute_resolved_api_SummarizeGeoNode.__qualname__ = "SummarizeGeoNode"
-scout_compute_resolved_api_SummarizeGeoNode.__module__ = "nominal_api.scout_compute_resolved_api"
-
-
 class scout_compute_resolved_api_SummarizeRangesNode(ConjureBeanType):
 
     @builtins.classmethod
@@ -75352,6 +75250,42 @@ Nominal connections which have their tags automatically indexed in the underlyin
         _decoder = ConjureDecoder()
         return _decoder.decode(_response.json(), List[scout_datasource_connection_api_Connection], self._return_none_for_unknown_union_types)
 
+    def list_connections_v2(self, auth_header: str, workspaces: List[str] = None, include_archived: Optional[bool] = None, next_page_token: Optional[str] = None, page_size: Optional[int] = None) -> "scout_datasource_connection_api_ListConnectionsResponse":
+        """Lists connections with pagination. Returns connections ordered by creation time descending.
+        """
+        workspaces = workspaces if workspaces is not None else []
+        _conjure_encoder = ConjureEncoder()
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+            'includeArchived': _conjure_encoder.default(include_archived),
+            'workspaces': _conjure_encoder.default(workspaces),
+            'pageSize': _conjure_encoder.default(page_size),
+            'nextPageToken': _conjure_encoder.default(next_page_token),
+        }
+
+        _path_params: Dict[str, str] = {
+        }
+
+        _json: Any = None
+
+        _path = '/data-source/connection/v2/connections'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'GET',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        _decoder = ConjureDecoder()
+        return _decoder.decode(_response.json(), scout_datasource_connection_api_ListConnectionsResponse, self._return_none_for_unknown_union_types)
+
     def archive_connection(self, auth_header: str, rid: str) -> None:
         """Archives a connection, which simply tags the connection for a client to filter.
         """
@@ -76727,6 +76661,35 @@ scout_datasource_connection_api_LimitsConfig.__qualname__ = "LimitsConfig"
 scout_datasource_connection_api_LimitsConfig.__module__ = "nominal_api.scout_datasource_connection_api"
 
 
+class scout_datasource_connection_api_ListConnectionsResponse(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'connections': ConjureFieldDefinition('connections', List[scout_datasource_connection_api_Connection]),
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token])
+        }
+
+    __slots__: List[str] = ['_connections', '_next_page_token']
+
+    def __init__(self, connections: List["scout_datasource_connection_api_Connection"], next_page_token: Optional[str] = None) -> None:
+        self._connections = connections
+        self._next_page_token = next_page_token
+
+    @builtins.property
+    def connections(self) -> List["scout_datasource_connection_api_Connection"]:
+        return self._connections
+
+    @builtins.property
+    def next_page_token(self) -> Optional[str]:
+        return self._next_page_token
+
+
+scout_datasource_connection_api_ListConnectionsResponse.__name__ = "ListConnectionsResponse"
+scout_datasource_connection_api_ListConnectionsResponse.__qualname__ = "ListConnectionsResponse"
+scout_datasource_connection_api_ListConnectionsResponse.__module__ = "nominal_api.scout_datasource_connection_api"
+
+
 class scout_datasource_connection_api_NominalChannelNameComponent(ConjureUnionType):
     _channel: Optional["api_Empty"] = None
     _value_of_tag_with_name: Optional[str] = None
@@ -78245,25 +78208,150 @@ scout_favorites_api_SetFavoritesListRequest.__qualname__ = "SetFavoritesListRequ
 scout_favorites_api_SetFavoritesListRequest.__module__ = "nominal_api.scout_favorites_api"
 
 
+class scout_integrations_api_AlertMessageFields(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'asset_title': ConjureFieldDefinition('assetTitle', str),
+            'check_title': ConjureFieldDefinition('checkTitle', str),
+            'check_description': ConjureFieldDefinition('checkDescription', str),
+            'checklist_title': ConjureFieldDefinition('checklistTitle', str),
+            'asset_rid': ConjureFieldDefinition('assetRid', scout_rids_api_AssetRid),
+            'check_lineage_rid': ConjureFieldDefinition('checkLineageRid', scout_rids_api_CheckLineageRid),
+            'workbook_url': ConjureFieldDefinition('workbookUrl', OptionalTypeWrapper[str]),
+            'alert_url': ConjureFieldDefinition('alertUrl', OptionalTypeWrapper[str]),
+            'event_type': ConjureFieldDefinition('eventType', event_EventType),
+            'priority': ConjureFieldDefinition('priority', scout_api_Priority),
+            'labels': ConjureFieldDefinition('labels', List[str]),
+            'alert_type': ConjureFieldDefinition('alertType', scout_integrations_api_AlertType)
+        }
+
+    __slots__: List[str] = ['_asset_title', '_check_title', '_check_description', '_checklist_title', '_asset_rid', '_check_lineage_rid', '_workbook_url', '_alert_url', '_event_type', '_priority', '_labels', '_alert_type']
+
+    def __init__(self, alert_type: "scout_integrations_api_AlertType", asset_rid: str, asset_title: str, check_description: str, check_lineage_rid: str, check_title: str, checklist_title: str, event_type: "event_EventType", labels: List[str], priority: "scout_api_Priority", alert_url: Optional[str] = None, workbook_url: Optional[str] = None) -> None:
+        self._asset_title = asset_title
+        self._check_title = check_title
+        self._check_description = check_description
+        self._checklist_title = checklist_title
+        self._asset_rid = asset_rid
+        self._check_lineage_rid = check_lineage_rid
+        self._workbook_url = workbook_url
+        self._alert_url = alert_url
+        self._event_type = event_type
+        self._priority = priority
+        self._labels = labels
+        self._alert_type = alert_type
+
+    @builtins.property
+    def asset_title(self) -> str:
+        return self._asset_title
+
+    @builtins.property
+    def check_title(self) -> str:
+        return self._check_title
+
+    @builtins.property
+    def check_description(self) -> str:
+        return self._check_description
+
+    @builtins.property
+    def checklist_title(self) -> str:
+        return self._checklist_title
+
+    @builtins.property
+    def asset_rid(self) -> str:
+        return self._asset_rid
+
+    @builtins.property
+    def check_lineage_rid(self) -> str:
+        return self._check_lineage_rid
+
+    @builtins.property
+    def workbook_url(self) -> Optional[str]:
+        """Appended to the end of the message as a button (if supported) or as a text hyperlink.
+        """
+        return self._workbook_url
+
+    @builtins.property
+    def alert_url(self) -> Optional[str]:
+        """Appended to the end of the message as a button (if supported) or as a text hyperlink.
+        """
+        return self._alert_url
+
+    @builtins.property
+    def event_type(self) -> "event_EventType":
+        """Will be prefixed in title and indicated by an icon.
+        """
+        return self._event_type
+
+    @builtins.property
+    def priority(self) -> "scout_api_Priority":
+        return self._priority
+
+    @builtins.property
+    def labels(self) -> List[str]:
+        """Currently exposed as 'tags' on the frontend to match Opsgenie naming. Used by some integrations to filter/route messages.
+        """
+        return self._labels
+
+    @builtins.property
+    def alert_type(self) -> "scout_integrations_api_AlertType":
+        """Determines execution status of the alert, between success, failure, and execution error.
+        """
+        return self._alert_type
+
+
+scout_integrations_api_AlertMessageFields.__name__ = "AlertMessageFields"
+scout_integrations_api_AlertMessageFields.__qualname__ = "AlertMessageFields"
+scout_integrations_api_AlertMessageFields.__module__ = "nominal_api.scout_integrations_api"
+
+
+class scout_integrations_api_AlertType(ConjureEnumType):
+
+    INVALID = 'INVALID'
+    '''INVALID'''
+    FAILURE = 'FAILURE'
+    '''FAILURE'''
+    RECOVERY = 'RECOVERY'
+    '''RECOVERY'''
+    UNKNOWN = 'UNKNOWN'
+    '''UNKNOWN'''
+
+    def __reduce_ex__(self, proto):
+        return self.__class__, (self.name,)
+
+
+scout_integrations_api_AlertType.__name__ = "AlertType"
+scout_integrations_api_AlertType.__qualname__ = "AlertType"
+scout_integrations_api_AlertType.__module__ = "nominal_api.scout_integrations_api"
+
+
 class scout_integrations_api_CreateIntegrationDetails(ConjureUnionType):
     _create_simple_webhook_details: Optional["scout_integrations_api_CreateSimpleWebhookDetails"] = None
     _create_opsgenie_integration_details: Optional["scout_integrations_api_CreateOpsgenieIntegrationDetails"] = None
+    _create_teams_webhook_integration_details: Optional["scout_integrations_api_CreateTeamsWebhookIntegrationDetails"] = None
+    _create_pager_duty_integration_details: Optional["scout_integrations_api_CreatePagerDutyIntegrationDetails"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'create_simple_webhook_details': ConjureFieldDefinition('createSimpleWebhookDetails', scout_integrations_api_CreateSimpleWebhookDetails),
-            'create_opsgenie_integration_details': ConjureFieldDefinition('createOpsgenieIntegrationDetails', scout_integrations_api_CreateOpsgenieIntegrationDetails)
+            'create_opsgenie_integration_details': ConjureFieldDefinition('createOpsgenieIntegrationDetails', scout_integrations_api_CreateOpsgenieIntegrationDetails),
+            'create_teams_webhook_integration_details': ConjureFieldDefinition('createTeamsWebhookIntegrationDetails', scout_integrations_api_CreateTeamsWebhookIntegrationDetails),
+            'create_pager_duty_integration_details': ConjureFieldDefinition('createPagerDutyIntegrationDetails', scout_integrations_api_CreatePagerDutyIntegrationDetails)
         }
 
     def __init__(
             self,
             create_simple_webhook_details: Optional["scout_integrations_api_CreateSimpleWebhookDetails"] = None,
             create_opsgenie_integration_details: Optional["scout_integrations_api_CreateOpsgenieIntegrationDetails"] = None,
+            create_teams_webhook_integration_details: Optional["scout_integrations_api_CreateTeamsWebhookIntegrationDetails"] = None,
+            create_pager_duty_integration_details: Optional["scout_integrations_api_CreatePagerDutyIntegrationDetails"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (create_simple_webhook_details is not None) + (create_opsgenie_integration_details is not None) != 1:
+            if (create_simple_webhook_details is not None) + (create_opsgenie_integration_details is not None) + (create_teams_webhook_integration_details is not None) + (create_pager_duty_integration_details is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if create_simple_webhook_details is not None:
@@ -78272,6 +78360,12 @@ class scout_integrations_api_CreateIntegrationDetails(ConjureUnionType):
             if create_opsgenie_integration_details is not None:
                 self._create_opsgenie_integration_details = create_opsgenie_integration_details
                 self._type = 'createOpsgenieIntegrationDetails'
+            if create_teams_webhook_integration_details is not None:
+                self._create_teams_webhook_integration_details = create_teams_webhook_integration_details
+                self._type = 'createTeamsWebhookIntegrationDetails'
+            if create_pager_duty_integration_details is not None:
+                self._create_pager_duty_integration_details = create_pager_duty_integration_details
+                self._type = 'createPagerDutyIntegrationDetails'
 
         elif type_of_union == 'createSimpleWebhookDetails':
             if create_simple_webhook_details is None:
@@ -78283,6 +78377,16 @@ class scout_integrations_api_CreateIntegrationDetails(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._create_opsgenie_integration_details = create_opsgenie_integration_details
             self._type = 'createOpsgenieIntegrationDetails'
+        elif type_of_union == 'createTeamsWebhookIntegrationDetails':
+            if create_teams_webhook_integration_details is None:
+                raise ValueError('a union value must not be None')
+            self._create_teams_webhook_integration_details = create_teams_webhook_integration_details
+            self._type = 'createTeamsWebhookIntegrationDetails'
+        elif type_of_union == 'createPagerDutyIntegrationDetails':
+            if create_pager_duty_integration_details is None:
+                raise ValueError('a union value must not be None')
+            self._create_pager_duty_integration_details = create_pager_duty_integration_details
+            self._type = 'createPagerDutyIntegrationDetails'
 
     @builtins.property
     def create_simple_webhook_details(self) -> Optional["scout_integrations_api_CreateSimpleWebhookDetails"]:
@@ -78292,6 +78396,14 @@ class scout_integrations_api_CreateIntegrationDetails(ConjureUnionType):
     def create_opsgenie_integration_details(self) -> Optional["scout_integrations_api_CreateOpsgenieIntegrationDetails"]:
         return self._create_opsgenie_integration_details
 
+    @builtins.property
+    def create_teams_webhook_integration_details(self) -> Optional["scout_integrations_api_CreateTeamsWebhookIntegrationDetails"]:
+        return self._create_teams_webhook_integration_details
+
+    @builtins.property
+    def create_pager_duty_integration_details(self) -> Optional["scout_integrations_api_CreatePagerDutyIntegrationDetails"]:
+        return self._create_pager_duty_integration_details
+
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, scout_integrations_api_CreateIntegrationDetailsVisitor):
             raise ValueError('{} is not an instance of scout_integrations_api_CreateIntegrationDetailsVisitor'.format(visitor.__class__.__name__))
@@ -78299,6 +78411,10 @@ class scout_integrations_api_CreateIntegrationDetails(ConjureUnionType):
             return visitor._create_simple_webhook_details(self.create_simple_webhook_details)
         if self._type == 'createOpsgenieIntegrationDetails' and self.create_opsgenie_integration_details is not None:
             return visitor._create_opsgenie_integration_details(self.create_opsgenie_integration_details)
+        if self._type == 'createTeamsWebhookIntegrationDetails' and self.create_teams_webhook_integration_details is not None:
+            return visitor._create_teams_webhook_integration_details(self.create_teams_webhook_integration_details)
+        if self._type == 'createPagerDutyIntegrationDetails' and self.create_pager_duty_integration_details is not None:
+            return visitor._create_pager_duty_integration_details(self.create_pager_duty_integration_details)
 
 
 scout_integrations_api_CreateIntegrationDetails.__name__ = "CreateIntegrationDetails"
@@ -78316,6 +78432,14 @@ class scout_integrations_api_CreateIntegrationDetailsVisitor:
     def _create_opsgenie_integration_details(self, create_opsgenie_integration_details: "scout_integrations_api_CreateOpsgenieIntegrationDetails") -> Any:
         pass
 
+    @abstractmethod
+    def _create_teams_webhook_integration_details(self, create_teams_webhook_integration_details: "scout_integrations_api_CreateTeamsWebhookIntegrationDetails") -> Any:
+        pass
+
+    @abstractmethod
+    def _create_pager_duty_integration_details(self, create_pager_duty_integration_details: "scout_integrations_api_CreatePagerDutyIntegrationDetails") -> Any:
+        pass
+
 
 scout_integrations_api_CreateIntegrationDetailsVisitor.__name__ = "CreateIntegrationDetailsVisitor"
 scout_integrations_api_CreateIntegrationDetailsVisitor.__qualname__ = "CreateIntegrationDetailsVisitor"
@@ -78395,6 +78519,29 @@ scout_integrations_api_CreateOpsgenieIntegrationDetails.__qualname__ = "CreateOp
 scout_integrations_api_CreateOpsgenieIntegrationDetails.__module__ = "nominal_api.scout_integrations_api"
 
 
+class scout_integrations_api_CreatePagerDutyIntegrationDetails(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'routing_key': ConjureFieldDefinition('routingKey', str)
+        }
+
+    __slots__: List[str] = ['_routing_key']
+
+    def __init__(self, routing_key: str) -> None:
+        self._routing_key = routing_key
+
+    @builtins.property
+    def routing_key(self) -> str:
+        return self._routing_key
+
+
+scout_integrations_api_CreatePagerDutyIntegrationDetails.__name__ = "CreatePagerDutyIntegrationDetails"
+scout_integrations_api_CreatePagerDutyIntegrationDetails.__qualname__ = "CreatePagerDutyIntegrationDetails"
+scout_integrations_api_CreatePagerDutyIntegrationDetails.__module__ = "nominal_api.scout_integrations_api"
+
+
 class scout_integrations_api_CreateSimpleWebhookDetails(ConjureBeanType):
 
     @builtins.classmethod
@@ -78418,6 +78565,29 @@ scout_integrations_api_CreateSimpleWebhookDetails.__qualname__ = "CreateSimpleWe
 scout_integrations_api_CreateSimpleWebhookDetails.__module__ = "nominal_api.scout_integrations_api"
 
 
+class scout_integrations_api_CreateTeamsWebhookIntegrationDetails(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'webhook': ConjureFieldDefinition('webhook', str)
+        }
+
+    __slots__: List[str] = ['_webhook']
+
+    def __init__(self, webhook: str) -> None:
+        self._webhook = webhook
+
+    @builtins.property
+    def webhook(self) -> str:
+        return self._webhook
+
+
+scout_integrations_api_CreateTeamsWebhookIntegrationDetails.__name__ = "CreateTeamsWebhookIntegrationDetails"
+scout_integrations_api_CreateTeamsWebhookIntegrationDetails.__qualname__ = "CreateTeamsWebhookIntegrationDetails"
+scout_integrations_api_CreateTeamsWebhookIntegrationDetails.__module__ = "nominal_api.scout_integrations_api"
+
+
 class scout_integrations_api_GenerateSlackWebhookResponse(ConjureBeanType):
 
     @builtins.classmethod
@@ -78506,13 +78676,17 @@ class scout_integrations_api_IntegrationDetails(ConjureUnionType):
     _slack_webhook_integration: Optional["scout_integrations_api_SlackWebhookIntegration"] = None
     _opsgenie_integration: Optional["scout_integrations_api_OpsgenieIntegration"] = None
     _simple_webhook_integration: Optional["scout_integrations_api_SimpleWebhookIntegration"] = None
+    _teams_webhook_integration: Optional["scout_integrations_api_TeamsWebhookIntegration"] = None
+    _pager_duty_integration: Optional["scout_integrations_api_PagerDutyIntegration"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'slack_webhook_integration': ConjureFieldDefinition('slackWebhookIntegration', scout_integrations_api_SlackWebhookIntegration),
             'opsgenie_integration': ConjureFieldDefinition('opsgenieIntegration', scout_integrations_api_OpsgenieIntegration),
-            'simple_webhook_integration': ConjureFieldDefinition('simpleWebhookIntegration', scout_integrations_api_SimpleWebhookIntegration)
+            'simple_webhook_integration': ConjureFieldDefinition('simpleWebhookIntegration', scout_integrations_api_SimpleWebhookIntegration),
+            'teams_webhook_integration': ConjureFieldDefinition('teamsWebhookIntegration', scout_integrations_api_TeamsWebhookIntegration),
+            'pager_duty_integration': ConjureFieldDefinition('pagerDutyIntegration', scout_integrations_api_PagerDutyIntegration)
         }
 
     def __init__(
@@ -78520,10 +78694,12 @@ class scout_integrations_api_IntegrationDetails(ConjureUnionType):
             slack_webhook_integration: Optional["scout_integrations_api_SlackWebhookIntegration"] = None,
             opsgenie_integration: Optional["scout_integrations_api_OpsgenieIntegration"] = None,
             simple_webhook_integration: Optional["scout_integrations_api_SimpleWebhookIntegration"] = None,
+            teams_webhook_integration: Optional["scout_integrations_api_TeamsWebhookIntegration"] = None,
+            pager_duty_integration: Optional["scout_integrations_api_PagerDutyIntegration"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (slack_webhook_integration is not None) + (opsgenie_integration is not None) + (simple_webhook_integration is not None) != 1:
+            if (slack_webhook_integration is not None) + (opsgenie_integration is not None) + (simple_webhook_integration is not None) + (teams_webhook_integration is not None) + (pager_duty_integration is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if slack_webhook_integration is not None:
@@ -78535,6 +78711,12 @@ class scout_integrations_api_IntegrationDetails(ConjureUnionType):
             if simple_webhook_integration is not None:
                 self._simple_webhook_integration = simple_webhook_integration
                 self._type = 'simpleWebhookIntegration'
+            if teams_webhook_integration is not None:
+                self._teams_webhook_integration = teams_webhook_integration
+                self._type = 'teamsWebhookIntegration'
+            if pager_duty_integration is not None:
+                self._pager_duty_integration = pager_duty_integration
+                self._type = 'pagerDutyIntegration'
 
         elif type_of_union == 'slackWebhookIntegration':
             if slack_webhook_integration is None:
@@ -78551,6 +78733,16 @@ class scout_integrations_api_IntegrationDetails(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._simple_webhook_integration = simple_webhook_integration
             self._type = 'simpleWebhookIntegration'
+        elif type_of_union == 'teamsWebhookIntegration':
+            if teams_webhook_integration is None:
+                raise ValueError('a union value must not be None')
+            self._teams_webhook_integration = teams_webhook_integration
+            self._type = 'teamsWebhookIntegration'
+        elif type_of_union == 'pagerDutyIntegration':
+            if pager_duty_integration is None:
+                raise ValueError('a union value must not be None')
+            self._pager_duty_integration = pager_duty_integration
+            self._type = 'pagerDutyIntegration'
 
     @builtins.property
     def slack_webhook_integration(self) -> Optional["scout_integrations_api_SlackWebhookIntegration"]:
@@ -78564,6 +78756,14 @@ class scout_integrations_api_IntegrationDetails(ConjureUnionType):
     def simple_webhook_integration(self) -> Optional["scout_integrations_api_SimpleWebhookIntegration"]:
         return self._simple_webhook_integration
 
+    @builtins.property
+    def teams_webhook_integration(self) -> Optional["scout_integrations_api_TeamsWebhookIntegration"]:
+        return self._teams_webhook_integration
+
+    @builtins.property
+    def pager_duty_integration(self) -> Optional["scout_integrations_api_PagerDutyIntegration"]:
+        return self._pager_duty_integration
+
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, scout_integrations_api_IntegrationDetailsVisitor):
             raise ValueError('{} is not an instance of scout_integrations_api_IntegrationDetailsVisitor'.format(visitor.__class__.__name__))
@@ -78573,6 +78773,10 @@ class scout_integrations_api_IntegrationDetails(ConjureUnionType):
             return visitor._opsgenie_integration(self.opsgenie_integration)
         if self._type == 'simpleWebhookIntegration' and self.simple_webhook_integration is not None:
             return visitor._simple_webhook_integration(self.simple_webhook_integration)
+        if self._type == 'teamsWebhookIntegration' and self.teams_webhook_integration is not None:
+            return visitor._teams_webhook_integration(self.teams_webhook_integration)
+        if self._type == 'pagerDutyIntegration' and self.pager_duty_integration is not None:
+            return visitor._pager_duty_integration(self.pager_duty_integration)
 
 
 scout_integrations_api_IntegrationDetails.__name__ = "IntegrationDetails"
@@ -78594,6 +78798,14 @@ class scout_integrations_api_IntegrationDetailsVisitor:
     def _simple_webhook_integration(self, simple_webhook_integration: "scout_integrations_api_SimpleWebhookIntegration") -> Any:
         pass
 
+    @abstractmethod
+    def _teams_webhook_integration(self, teams_webhook_integration: "scout_integrations_api_TeamsWebhookIntegration") -> Any:
+        pass
+
+    @abstractmethod
+    def _pager_duty_integration(self, pager_duty_integration: "scout_integrations_api_PagerDutyIntegration") -> Any:
+        pass
+
 
 scout_integrations_api_IntegrationDetailsVisitor.__name__ = "IntegrationDetailsVisitor"
 scout_integrations_api_IntegrationDetailsVisitor.__qualname__ = "IntegrationDetailsVisitor"
@@ -78901,6 +79113,112 @@ scout_integrations_api_IntegrationsService.__qualname__ = "IntegrationsService"
 scout_integrations_api_IntegrationsService.__module__ = "nominal_api.scout_integrations_api"
 
 
+class scout_integrations_api_InternalSendMessageRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'integration_rid': ConjureFieldDefinition('integrationRid', scout_integrations_api_IntegrationRid),
+            'message': ConjureFieldDefinition('message', scout_integrations_api_MessageFields)
+        }
+
+    __slots__: List[str] = ['_integration_rid', '_message']
+
+    def __init__(self, integration_rid: str, message: "scout_integrations_api_MessageFields") -> None:
+        self._integration_rid = integration_rid
+        self._message = message
+
+    @builtins.property
+    def integration_rid(self) -> str:
+        return self._integration_rid
+
+    @builtins.property
+    def message(self) -> "scout_integrations_api_MessageFields":
+        return self._message
+
+
+scout_integrations_api_InternalSendMessageRequest.__name__ = "InternalSendMessageRequest"
+scout_integrations_api_InternalSendMessageRequest.__qualname__ = "InternalSendMessageRequest"
+scout_integrations_api_InternalSendMessageRequest.__module__ = "nominal_api.scout_integrations_api"
+
+
+class scout_integrations_api_MessageFields(ConjureUnionType):
+    _alert: Optional["scout_integrations_api_AlertMessageFields"] = None
+    _resolution_error: Optional["scout_integrations_api_ResolutionFailureMessageFields"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'alert': ConjureFieldDefinition('alert', scout_integrations_api_AlertMessageFields),
+            'resolution_error': ConjureFieldDefinition('resolutionError', scout_integrations_api_ResolutionFailureMessageFields)
+        }
+
+    def __init__(
+            self,
+            alert: Optional["scout_integrations_api_AlertMessageFields"] = None,
+            resolution_error: Optional["scout_integrations_api_ResolutionFailureMessageFields"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (alert is not None) + (resolution_error is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if alert is not None:
+                self._alert = alert
+                self._type = 'alert'
+            if resolution_error is not None:
+                self._resolution_error = resolution_error
+                self._type = 'resolutionError'
+
+        elif type_of_union == 'alert':
+            if alert is None:
+                raise ValueError('a union value must not be None')
+            self._alert = alert
+            self._type = 'alert'
+        elif type_of_union == 'resolutionError':
+            if resolution_error is None:
+                raise ValueError('a union value must not be None')
+            self._resolution_error = resolution_error
+            self._type = 'resolutionError'
+
+    @builtins.property
+    def alert(self) -> Optional["scout_integrations_api_AlertMessageFields"]:
+        return self._alert
+
+    @builtins.property
+    def resolution_error(self) -> Optional["scout_integrations_api_ResolutionFailureMessageFields"]:
+        return self._resolution_error
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_integrations_api_MessageFieldsVisitor):
+            raise ValueError('{} is not an instance of scout_integrations_api_MessageFieldsVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'alert' and self.alert is not None:
+            return visitor._alert(self.alert)
+        if self._type == 'resolutionError' and self.resolution_error is not None:
+            return visitor._resolution_error(self.resolution_error)
+
+
+scout_integrations_api_MessageFields.__name__ = "MessageFields"
+scout_integrations_api_MessageFields.__qualname__ = "MessageFields"
+scout_integrations_api_MessageFields.__module__ = "nominal_api.scout_integrations_api"
+
+
+class scout_integrations_api_MessageFieldsVisitor:
+
+    @abstractmethod
+    def _alert(self, alert: "scout_integrations_api_AlertMessageFields") -> Any:
+        pass
+
+    @abstractmethod
+    def _resolution_error(self, resolution_error: "scout_integrations_api_ResolutionFailureMessageFields") -> Any:
+        pass
+
+
+scout_integrations_api_MessageFieldsVisitor.__name__ = "MessageFieldsVisitor"
+scout_integrations_api_MessageFieldsVisitor.__qualname__ = "MessageFieldsVisitor"
+scout_integrations_api_MessageFieldsVisitor.__module__ = "nominal_api.scout_integrations_api"
+
+
 class scout_integrations_api_NotificationConfiguration(ConjureBeanType):
     """Configuration details to send notifications to a linked integration.
     """
@@ -79011,6 +79329,83 @@ scout_integrations_api_OpsgenieRegion.__qualname__ = "OpsgenieRegion"
 scout_integrations_api_OpsgenieRegion.__module__ = "nominal_api.scout_integrations_api"
 
 
+class scout_integrations_api_PagerDutyIntegration(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+        }
+
+    __slots__: List[str] = []
+
+
+
+scout_integrations_api_PagerDutyIntegration.__name__ = "PagerDutyIntegration"
+scout_integrations_api_PagerDutyIntegration.__qualname__ = "PagerDutyIntegration"
+scout_integrations_api_PagerDutyIntegration.__module__ = "nominal_api.scout_integrations_api"
+
+
+class scout_integrations_api_ResolutionFailureMessageFields(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'checklist_title': ConjureFieldDefinition('checklistTitle', str),
+            'asset_title': ConjureFieldDefinition('assetTitle', str),
+            'checklist_rid': ConjureFieldDefinition('checklistRid', scout_rids_api_ChecklistRid),
+            'asset_rid': ConjureFieldDefinition('assetRid', scout_rids_api_AssetRid),
+            'unresolved_checks': ConjureFieldDefinition('unresolvedChecks', int),
+            'total_checks': ConjureFieldDefinition('totalChecks', int),
+            'labels': ConjureFieldDefinition('labels', List[str])
+        }
+
+    __slots__: List[str] = ['_checklist_title', '_asset_title', '_checklist_rid', '_asset_rid', '_unresolved_checks', '_total_checks', '_labels']
+
+    def __init__(self, asset_rid: str, asset_title: str, checklist_rid: str, checklist_title: str, labels: List[str], total_checks: int, unresolved_checks: int) -> None:
+        self._checklist_title = checklist_title
+        self._asset_title = asset_title
+        self._checklist_rid = checklist_rid
+        self._asset_rid = asset_rid
+        self._unresolved_checks = unresolved_checks
+        self._total_checks = total_checks
+        self._labels = labels
+
+    @builtins.property
+    def checklist_title(self) -> str:
+        return self._checklist_title
+
+    @builtins.property
+    def asset_title(self) -> str:
+        return self._asset_title
+
+    @builtins.property
+    def checklist_rid(self) -> str:
+        return self._checklist_rid
+
+    @builtins.property
+    def asset_rid(self) -> str:
+        return self._asset_rid
+
+    @builtins.property
+    def unresolved_checks(self) -> int:
+        return self._unresolved_checks
+
+    @builtins.property
+    def total_checks(self) -> int:
+        return self._total_checks
+
+    @builtins.property
+    def labels(self) -> List[str]:
+        """Currently exposed as 'tags' on the frontend to match Opsgenie naming. Used by some integrations to filter/route messages.
+        """
+        return self._labels
+
+
+scout_integrations_api_ResolutionFailureMessageFields.__name__ = "ResolutionFailureMessageFields"
+scout_integrations_api_ResolutionFailureMessageFields.__qualname__ = "ResolutionFailureMessageFields"
+scout_integrations_api_ResolutionFailureMessageFields.__module__ = "nominal_api.scout_integrations_api"
+
+
 class scout_integrations_api_SendMessageRequest(ConjureBeanType):
 
     @builtins.classmethod
@@ -79145,25 +79540,47 @@ scout_integrations_api_SlackWebhookIntegration.__qualname__ = "SlackWebhookInteg
 scout_integrations_api_SlackWebhookIntegration.__module__ = "nominal_api.scout_integrations_api"
 
 
+class scout_integrations_api_TeamsWebhookIntegration(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+        }
+
+    __slots__: List[str] = []
+
+
+
+scout_integrations_api_TeamsWebhookIntegration.__name__ = "TeamsWebhookIntegration"
+scout_integrations_api_TeamsWebhookIntegration.__qualname__ = "TeamsWebhookIntegration"
+scout_integrations_api_TeamsWebhookIntegration.__module__ = "nominal_api.scout_integrations_api"
+
+
 class scout_integrations_api_UpdateIntegrationDetails(ConjureUnionType):
     _simple_webhook: Optional["scout_integrations_api_UpdateSimpleWebhookDetails"] = None
     _opsgenie_integration: Optional["scout_integrations_api_UpdateOpsgenieIntegrationDetails"] = None
+    _teams_webhook: Optional["scout_integrations_api_UpdateTeamsWebhookIntegrationDetails"] = None
+    _pager_duty: Optional["scout_integrations_api_UpdatePagerDutyIntegrationDetails"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'simple_webhook': ConjureFieldDefinition('simpleWebhook', scout_integrations_api_UpdateSimpleWebhookDetails),
-            'opsgenie_integration': ConjureFieldDefinition('opsgenieIntegration', scout_integrations_api_UpdateOpsgenieIntegrationDetails)
+            'opsgenie_integration': ConjureFieldDefinition('opsgenieIntegration', scout_integrations_api_UpdateOpsgenieIntegrationDetails),
+            'teams_webhook': ConjureFieldDefinition('teamsWebhook', scout_integrations_api_UpdateTeamsWebhookIntegrationDetails),
+            'pager_duty': ConjureFieldDefinition('pagerDuty', scout_integrations_api_UpdatePagerDutyIntegrationDetails)
         }
 
     def __init__(
             self,
             simple_webhook: Optional["scout_integrations_api_UpdateSimpleWebhookDetails"] = None,
             opsgenie_integration: Optional["scout_integrations_api_UpdateOpsgenieIntegrationDetails"] = None,
+            teams_webhook: Optional["scout_integrations_api_UpdateTeamsWebhookIntegrationDetails"] = None,
+            pager_duty: Optional["scout_integrations_api_UpdatePagerDutyIntegrationDetails"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (simple_webhook is not None) + (opsgenie_integration is not None) != 1:
+            if (simple_webhook is not None) + (opsgenie_integration is not None) + (teams_webhook is not None) + (pager_duty is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if simple_webhook is not None:
@@ -79172,6 +79589,12 @@ class scout_integrations_api_UpdateIntegrationDetails(ConjureUnionType):
             if opsgenie_integration is not None:
                 self._opsgenie_integration = opsgenie_integration
                 self._type = 'opsgenieIntegration'
+            if teams_webhook is not None:
+                self._teams_webhook = teams_webhook
+                self._type = 'teamsWebhook'
+            if pager_duty is not None:
+                self._pager_duty = pager_duty
+                self._type = 'pagerDuty'
 
         elif type_of_union == 'simpleWebhook':
             if simple_webhook is None:
@@ -79183,6 +79606,16 @@ class scout_integrations_api_UpdateIntegrationDetails(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._opsgenie_integration = opsgenie_integration
             self._type = 'opsgenieIntegration'
+        elif type_of_union == 'teamsWebhook':
+            if teams_webhook is None:
+                raise ValueError('a union value must not be None')
+            self._teams_webhook = teams_webhook
+            self._type = 'teamsWebhook'
+        elif type_of_union == 'pagerDuty':
+            if pager_duty is None:
+                raise ValueError('a union value must not be None')
+            self._pager_duty = pager_duty
+            self._type = 'pagerDuty'
 
     @builtins.property
     def simple_webhook(self) -> Optional["scout_integrations_api_UpdateSimpleWebhookDetails"]:
@@ -79192,6 +79625,14 @@ class scout_integrations_api_UpdateIntegrationDetails(ConjureUnionType):
     def opsgenie_integration(self) -> Optional["scout_integrations_api_UpdateOpsgenieIntegrationDetails"]:
         return self._opsgenie_integration
 
+    @builtins.property
+    def teams_webhook(self) -> Optional["scout_integrations_api_UpdateTeamsWebhookIntegrationDetails"]:
+        return self._teams_webhook
+
+    @builtins.property
+    def pager_duty(self) -> Optional["scout_integrations_api_UpdatePagerDutyIntegrationDetails"]:
+        return self._pager_duty
+
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, scout_integrations_api_UpdateIntegrationDetailsVisitor):
             raise ValueError('{} is not an instance of scout_integrations_api_UpdateIntegrationDetailsVisitor'.format(visitor.__class__.__name__))
@@ -79199,6 +79640,10 @@ class scout_integrations_api_UpdateIntegrationDetails(ConjureUnionType):
             return visitor._simple_webhook(self.simple_webhook)
         if self._type == 'opsgenieIntegration' and self.opsgenie_integration is not None:
             return visitor._opsgenie_integration(self.opsgenie_integration)
+        if self._type == 'teamsWebhook' and self.teams_webhook is not None:
+            return visitor._teams_webhook(self.teams_webhook)
+        if self._type == 'pagerDuty' and self.pager_duty is not None:
+            return visitor._pager_duty(self.pager_duty)
 
 
 scout_integrations_api_UpdateIntegrationDetails.__name__ = "UpdateIntegrationDetails"
@@ -79216,6 +79661,14 @@ class scout_integrations_api_UpdateIntegrationDetailsVisitor:
     def _opsgenie_integration(self, opsgenie_integration: "scout_integrations_api_UpdateOpsgenieIntegrationDetails") -> Any:
         pass
 
+    @abstractmethod
+    def _teams_webhook(self, teams_webhook: "scout_integrations_api_UpdateTeamsWebhookIntegrationDetails") -> Any:
+        pass
+
+    @abstractmethod
+    def _pager_duty(self, pager_duty: "scout_integrations_api_UpdatePagerDutyIntegrationDetails") -> Any:
+        pass
+
 
 scout_integrations_api_UpdateIntegrationDetailsVisitor.__name__ = "UpdateIntegrationDetailsVisitor"
 scout_integrations_api_UpdateIntegrationDetailsVisitor.__qualname__ = "UpdateIntegrationDetailsVisitor"
@@ -79306,6 +79759,29 @@ scout_integrations_api_UpdateOpsgenieIntegrationDetails.__qualname__ = "UpdateOp
 scout_integrations_api_UpdateOpsgenieIntegrationDetails.__module__ = "nominal_api.scout_integrations_api"
 
 
+class scout_integrations_api_UpdatePagerDutyIntegrationDetails(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'routing_key': ConjureFieldDefinition('routingKey', str)
+        }
+
+    __slots__: List[str] = ['_routing_key']
+
+    def __init__(self, routing_key: str) -> None:
+        self._routing_key = routing_key
+
+    @builtins.property
+    def routing_key(self) -> str:
+        return self._routing_key
+
+
+scout_integrations_api_UpdatePagerDutyIntegrationDetails.__name__ = "UpdatePagerDutyIntegrationDetails"
+scout_integrations_api_UpdatePagerDutyIntegrationDetails.__qualname__ = "UpdatePagerDutyIntegrationDetails"
+scout_integrations_api_UpdatePagerDutyIntegrationDetails.__module__ = "nominal_api.scout_integrations_api"
+
+
 class scout_integrations_api_UpdateSimpleWebhookDetails(ConjureBeanType):
 
     @builtins.classmethod
@@ -79329,6 +79805,29 @@ scout_integrations_api_UpdateSimpleWebhookDetails.__qualname__ = "UpdateSimpleWe
 scout_integrations_api_UpdateSimpleWebhookDetails.__module__ = "nominal_api.scout_integrations_api"
 
 
+class scout_integrations_api_UpdateTeamsWebhookIntegrationDetails(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'webhook': ConjureFieldDefinition('webhook', str)
+        }
+
+    __slots__: List[str] = ['_webhook']
+
+    def __init__(self, webhook: str) -> None:
+        self._webhook = webhook
+
+    @builtins.property
+    def webhook(self) -> str:
+        return self._webhook
+
+
+scout_integrations_api_UpdateTeamsWebhookIntegrationDetails.__name__ = "UpdateTeamsWebhookIntegrationDetails"
+scout_integrations_api_UpdateTeamsWebhookIntegrationDetails.__qualname__ = "UpdateTeamsWebhookIntegrationDetails"
+scout_integrations_api_UpdateTeamsWebhookIntegrationDetails.__module__ = "nominal_api.scout_integrations_api"
+
+
 class scout_internal_search_api_BooleanField(ConjureBeanType):
 
     @builtins.classmethod
@@ -81544,13 +82043,14 @@ class scout_notebook_api_NotebookMetadata(ConjureBeanType):
             'lock': ConjureFieldDefinition('lock', scout_notebook_api_Lock),
             'created_by_rid': ConjureFieldDefinition('createdByRid', scout_rids_api_UserRid),
             'created_at': ConjureFieldDefinition('createdAt', str),
+            'updated_at': ConjureFieldDefinition('updatedAt', OptionalTypeWrapper[str]),
             'properties': ConjureFieldDefinition('properties', Dict[api_PropertyName, api_PropertyValue]),
             'labels': ConjureFieldDefinition('labels', List[api_Label])
         }
 
-    __slots__: List[str] = ['_run_rid', '_data_scope', '_notebook_type', '_title', '_description', '_is_draft', '_is_archived', '_lock', '_created_by_rid', '_created_at', '_properties', '_labels']
+    __slots__: List[str] = ['_run_rid', '_data_scope', '_notebook_type', '_title', '_description', '_is_draft', '_is_archived', '_lock', '_created_by_rid', '_created_at', '_updated_at', '_properties', '_labels']
 
-    def __init__(self, created_at: str, created_by_rid: str, data_scope: "scout_notebook_api_NotebookDataScope", description: str, is_archived: bool, is_draft: bool, labels: List[str], lock: "scout_notebook_api_Lock", notebook_type: "scout_notebook_api_NotebookType", properties: Dict[str, str], title: str, run_rid: Optional[str] = None) -> None:
+    def __init__(self, created_at: str, created_by_rid: str, data_scope: "scout_notebook_api_NotebookDataScope", description: str, is_archived: bool, is_draft: bool, labels: List[str], lock: "scout_notebook_api_Lock", notebook_type: "scout_notebook_api_NotebookType", properties: Dict[str, str], title: str, run_rid: Optional[str] = None, updated_at: Optional[str] = None) -> None:
         self._run_rid = run_rid
         self._data_scope = data_scope
         self._notebook_type = notebook_type
@@ -81561,6 +82061,7 @@ class scout_notebook_api_NotebookMetadata(ConjureBeanType):
         self._lock = lock
         self._created_by_rid = created_by_rid
         self._created_at = created_at
+        self._updated_at = updated_at
         self._properties = properties
         self._labels = labels
 
@@ -81606,6 +82107,12 @@ class scout_notebook_api_NotebookMetadata(ConjureBeanType):
     def created_at(self) -> str:
         return self._created_at
 
+    @builtins.property
+    def updated_at(self) -> Optional[str]:
+        """The timestamp when the workbook was last updated
+        """
+        return self._updated_at
+
     @builtins.property
     def properties(self) -> Dict[str, str]:
         return self._properties
@@ -86460,23 +86967,26 @@ scout_savedviews_api_AssetMetricColumn.__module__ = "nominal_api.scout_savedview
 
 class scout_savedviews_api_AssetMetricColumnTimeRange(ConjureUnionType):
     _most_recent_run: Optional["scout_savedviews_api_MostRecentRun"] = None
-    _custom: Optional["scout_savedviews_api_CustomTimeRange"] = None
+    _custom: Optional["scout_run_api_CustomTimeframeFilter"] = None
+    _preset: Optional["scout_run_api_PresetTimeframeFilter"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'most_recent_run': ConjureFieldDefinition('mostRecentRun', scout_savedviews_api_MostRecentRun),
-            'custom': ConjureFieldDefinition('custom', scout_savedviews_api_CustomTimeRange)
+            'custom': ConjureFieldDefinition('custom', scout_run_api_CustomTimeframeFilter),
+            'preset': ConjureFieldDefinition('preset', scout_run_api_PresetTimeframeFilter)
         }
 
     def __init__(
             self,
             most_recent_run: Optional["scout_savedviews_api_MostRecentRun"] = None,
-            custom: Optional["scout_savedviews_api_CustomTimeRange"] = None,
+            custom: Optional["scout_run_api_CustomTimeframeFilter"] = None,
+            preset: Optional["scout_run_api_PresetTimeframeFilter"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (most_recent_run is not None) + (custom is not None) != 1:
+            if (most_recent_run is not None) + (custom is not None) + (preset is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if most_recent_run is not None:
@@ -86485,6 +86995,9 @@ class scout_savedviews_api_AssetMetricColumnTimeRange(ConjureUnionType):
             if custom is not None:
                 self._custom = custom
                 self._type = 'custom'
+            if preset is not None:
+                self._preset = preset
+                self._type = 'preset'
 
         elif type_of_union == 'mostRecentRun':
             if most_recent_run is None:
@@ -86496,15 +87009,24 @@ class scout_savedviews_api_AssetMetricColumnTimeRange(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._custom = custom
             self._type = 'custom'
+        elif type_of_union == 'preset':
+            if preset is None:
+                raise ValueError('a union value must not be None')
+            self._preset = preset
+            self._type = 'preset'
 
     @builtins.property
     def most_recent_run(self) -> Optional["scout_savedviews_api_MostRecentRun"]:
         return self._most_recent_run
 
     @builtins.property
-    def custom(self) -> Optional["scout_savedviews_api_CustomTimeRange"]:
+    def custom(self) -> Optional["scout_run_api_CustomTimeframeFilter"]:
         return self._custom
 
+    @builtins.property
+    def preset(self) -> Optional["scout_run_api_PresetTimeframeFilter"]:
+        return self._preset
+
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, scout_savedviews_api_AssetMetricColumnTimeRangeVisitor):
             raise ValueError('{} is not an instance of scout_savedviews_api_AssetMetricColumnTimeRangeVisitor'.format(visitor.__class__.__name__))
@@ -86512,6 +87034,8 @@ class scout_savedviews_api_AssetMetricColumnTimeRange(ConjureUnionType):
             return visitor._most_recent_run(self.most_recent_run)
         if self._type == 'custom' and self.custom is not None:
             return visitor._custom(self.custom)
+        if self._type == 'preset' and self.preset is not None:
+            return visitor._preset(self.preset)
 
 
 scout_savedviews_api_AssetMetricColumnTimeRange.__name__ = "AssetMetricColumnTimeRange"
@@ -86526,7 +87050,11 @@ class scout_savedviews_api_AssetMetricColumnTimeRangeVisitor:
         pass
 
     @abstractmethod
-    def _custom(self, custom: "scout_savedviews_api_CustomTimeRange") -> Any:
+    def _custom(self, custom: "scout_run_api_CustomTimeframeFilter") -> Any:
+        pass
+
+    @abstractmethod
+    def _preset(self, preset: "scout_run_api_PresetTimeframeFilter") -> Any:
         pass
 
 
@@ -86750,35 +87278,6 @@ scout_savedviews_api_CreateSavedViewResponse.__qualname__ = "CreateSavedViewResp
 scout_savedviews_api_CreateSavedViewResponse.__module__ = "nominal_api.scout_savedviews_api"
 
 
-class scout_savedviews_api_CustomTimeRange(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'start_time': ConjureFieldDefinition('startTime', OptionalTypeWrapper[scout_run_api_UtcTimestamp]),
-            'end_time': ConjureFieldDefinition('endTime', OptionalTypeWrapper[scout_run_api_UtcTimestamp])
-        }
-
-    __slots__: List[str] = ['_start_time', '_end_time']
-
-    def __init__(self, end_time: Optional["scout_run_api_UtcTimestamp"] = None, start_time: Optional["scout_run_api_UtcTimestamp"] = None) -> None:
-        self._start_time = start_time
-        self._end_time = end_time
-
-    @builtins.property
-    def start_time(self) -> Optional["scout_run_api_UtcTimestamp"]:
-        return self._start_time
-
-    @builtins.property
-    def end_time(self) -> Optional["scout_run_api_UtcTimestamp"]:
-        return self._end_time
-
-
-scout_savedviews_api_CustomTimeRange.__name__ = "CustomTimeRange"
-scout_savedviews_api_CustomTimeRange.__qualname__ = "CustomTimeRange"
-scout_savedviews_api_CustomTimeRange.__module__ = "nominal_api.scout_savedviews_api"
-
-
 class scout_savedviews_api_DisplayState(ConjureUnionType):
     _display_state_v1: Optional["scout_savedviews_api_TableState"] = None
 
@@ -90720,9 +91219,14 @@ permanently delete it. Archived videos can be unarchived.
 
         return
 
-    def get_playlist(self, auth_header: str, video_rid: str) -> Any:
-        """Generates an HLS playlist for a video with the given video rid to enable playback. The HLS playlist will contain
-links to all of the segments in the video in sequential order.
+    def get_playlist(self, auth_header: str, video_rid: str, end: Optional[str] = None, start: Optional[str] = None) -> Any:
+        """Generates an HLS playlist for a video within optional time bounds.
+Uses GET with query parameters for HLS.js compatibility.
+The HLS playlist will contain links to all of the segments in the video that overlap with the given bounds,
+or all segments if no bounds are provided.
+
+Note: The start and end parameters must either both be provided or both be omitted.
+Providing only one will result in a MissingTimestampBoundPair error.
         """
         _conjure_encoder = ConjureEncoder()
 
@@ -90732,6 +91236,8 @@ links to all of the segments in the video in sequential order.
         }
 
         _params: Dict[str, Any] = {
+            'start': _conjure_encoder.default(start),
+            'end': _conjure_encoder.default(end),
         }
 
         _path_params: Dict[str, str] = {
@@ -90826,6 +91332,84 @@ playlist will be limited to the given bounds.
         _raw.decode_content = True
         return _raw
 
+    def get_playlist_in_bounds_for_channel(self, auth_header: str, request: "scout_video_api_GetPlaylistInBoundsForChannelRequest") -> Any:
+        """Generates an HLS playlist for a video channel series (identified by channel + tags) within an optional set of
+bounds then generates a playlist for all matching video segments.
+        """
+        _conjure_encoder = ConjureEncoder()
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/octet-stream',
+            'Content-Type': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, str] = {
+        }
+
+        _json: Any = _conjure_encoder.default(request)
+
+        _path = '/video/v1/videos/channel/playlist-in-bounds'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'POST',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            stream=True,
+            json=_json)
+
+        _raw = _response.raw
+        _raw.decode_content = True
+        return _raw
+
+    def get_playlist_for_channel(self, auth_header: str, channel: str, end: str, start: str, asset_rid: Optional[str] = None, data_scope_name: Optional[str] = None, data_source_rid: Optional[str] = None, tags: Optional[str] = None) -> Any:
+        """Generates an HLS playlist for a video channel series within time bounds.
+Specify either dataSourceRid OR (assetRid + dataScopeName) to identify the channel source.
+
+Note: Both start and end parameters are required and must be provided together.
+        """
+        _conjure_encoder = ConjureEncoder()
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/octet-stream',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+            'dataSourceRid': _conjure_encoder.default(data_source_rid),
+            'assetRid': _conjure_encoder.default(asset_rid),
+            'dataScopeName': _conjure_encoder.default(data_scope_name),
+            'channel': _conjure_encoder.default(channel),
+            'tags': _conjure_encoder.default(tags),
+            'start': _conjure_encoder.default(start),
+            'end': _conjure_encoder.default(end),
+        }
+
+        _path_params: Dict[str, str] = {
+        }
+
+        _json: Any = None
+
+        _path = '/video/v1/videos/channel/playlist'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'GET',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            stream=True,
+            json=_json)
+
+        _raw = _response.raw
+        _raw.decode_content = True
+        return _raw
+
     def get_segment_summaries_in_bounds(self, auth_header: str, request: "scout_video_api_GetSegmentSummariesInBoundsRequest", video_rid: str) -> List["scout_video_api_SegmentSummary"]:
         """Returns the min and max absolute and media timestamps for each segment in a video that overlap with an 
 optional set of bounds.
@@ -90860,6 +91444,39 @@ optional set of bounds.
         _decoder = ConjureDecoder()
         return _decoder.decode(_response.json(), List[scout_video_api_SegmentSummary], self._return_none_for_unknown_union_types)
 
+    def get_segment_summaries_in_bounds_for_channel(self, auth_header: str, request: "scout_video_api_GetSegmentSummariesInBoundsForChannelRequest") -> List["scout_video_api_SegmentSummary"]:
+        """Returns the min and max absolute and media timestamps for each segment matching a video channel series 
+(identified by channel + tags) within the specified bounds.
+        """
+        _conjure_encoder = ConjureEncoder()
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, str] = {
+        }
+
+        _json: Any = _conjure_encoder.default(request)
+
+        _path = '/video/v1/videos/channel/segment-summaries-in-bounds'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'POST',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        _decoder = ConjureDecoder()
+        return _decoder.decode(_response.json(), List[scout_video_api_SegmentSummary], self._return_none_for_unknown_union_types)
+
     def get_file_summaries(self, auth_header: str, request: "scout_video_api_GetFileSummariesRequest", video_rid: str) -> "scout_video_api_GetFileSummariesResponse":
         """Returns the min and max absolute timestamps from non-archived video files associated with a given video that
 overlap with an optional set of bounds. The files on the edges of the bounds will be truncated to segments
@@ -91610,6 +92227,38 @@ scout_video_api_GetIngestStatusResponse.__qualname__ = "GetIngestStatusResponse"
 scout_video_api_GetIngestStatusResponse.__module__ = "nominal_api.scout_video_api"
 
 
+class scout_video_api_GetPlaylistInBoundsForChannelRequest(ConjureBeanType):
+    """Request to get playlist for a video channel series.
+Uses channel + tags to resolve to video series metadata within the specified video.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'channel_series': ConjureFieldDefinition('channelSeries', scout_video_api_VideoChannelSeries),
+            'bounds': ConjureFieldDefinition('bounds', scout_video_api_Bounds)
+        }
+
+    __slots__: List[str] = ['_channel_series', '_bounds']
+
+    def __init__(self, bounds: "scout_video_api_Bounds", channel_series: "scout_video_api_VideoChannelSeries") -> None:
+        self._channel_series = channel_series
+        self._bounds = bounds
+
+    @builtins.property
+    def channel_series(self) -> "scout_video_api_VideoChannelSeries":
+        return self._channel_series
+
+    @builtins.property
+    def bounds(self) -> "scout_video_api_Bounds":
+        return self._bounds
+
+
+scout_video_api_GetPlaylistInBoundsForChannelRequest.__name__ = "GetPlaylistInBoundsForChannelRequest"
+scout_video_api_GetPlaylistInBoundsForChannelRequest.__qualname__ = "GetPlaylistInBoundsForChannelRequest"
+scout_video_api_GetPlaylistInBoundsForChannelRequest.__module__ = "nominal_api.scout_video_api"
+
+
 class scout_video_api_GetPlaylistInBoundsRequest(ConjureBeanType):
 
     @builtins.classmethod
@@ -91668,6 +92317,38 @@ scout_video_api_GetSegmentByTimestampRequest.__qualname__ = "GetSegmentByTimesta
 scout_video_api_GetSegmentByTimestampRequest.__module__ = "nominal_api.scout_video_api"
 
 
+class scout_video_api_GetSegmentSummariesInBoundsForChannelRequest(ConjureBeanType):
+    """Request to get segment summaries for a video channel series.
+Uses channel + tags to resolve to video series metadata within the specified bounds.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'channel_series': ConjureFieldDefinition('channelSeries', scout_video_api_VideoChannelSeries),
+            'bounds': ConjureFieldDefinition('bounds', scout_video_api_Bounds)
+        }
+
+    __slots__: List[str] = ['_channel_series', '_bounds']
+
+    def __init__(self, bounds: "scout_video_api_Bounds", channel_series: "scout_video_api_VideoChannelSeries") -> None:
+        self._channel_series = channel_series
+        self._bounds = bounds
+
+    @builtins.property
+    def channel_series(self) -> "scout_video_api_VideoChannelSeries":
+        return self._channel_series
+
+    @builtins.property
+    def bounds(self) -> "scout_video_api_Bounds":
+        return self._bounds
+
+
+scout_video_api_GetSegmentSummariesInBoundsForChannelRequest.__name__ = "GetSegmentSummariesInBoundsForChannelRequest"
+scout_video_api_GetSegmentSummariesInBoundsForChannelRequest.__qualname__ = "GetSegmentSummariesInBoundsForChannelRequest"
+scout_video_api_GetSegmentSummariesInBoundsForChannelRequest.__module__ = "nominal_api.scout_video_api"
+
+
 class scout_video_api_GetSegmentSummariesInBoundsRequest(ConjureBeanType):
 
     @builtins.classmethod
@@ -92947,6 +93628,166 @@ scout_video_api_VideoAllSegmentsMetadata.__qualname__ = "VideoAllSegmentsMetadat
 scout_video_api_VideoAllSegmentsMetadata.__module__ = "nominal_api.scout_video_api"
 
 
+class scout_video_api_VideoAssetChannel(ConjureBeanType):
+    """Reference a video channel via an Asset's data scope
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'asset_rid': ConjureFieldDefinition('assetRid', str),
+            'data_scope_name': ConjureFieldDefinition('dataScopeName', str),
+            'channel': ConjureFieldDefinition('channel', str),
+            'tags': ConjureFieldDefinition('tags', Dict[api_TagName, api_TagValue])
+        }
+
+    __slots__: List[str] = ['_asset_rid', '_data_scope_name', '_channel', '_tags']
+
+    def __init__(self, asset_rid: str, channel: str, data_scope_name: str, tags: Dict[str, str]) -> None:
+        self._asset_rid = asset_rid
+        self._data_scope_name = data_scope_name
+        self._channel = channel
+        self._tags = tags
+
+    @builtins.property
+    def asset_rid(self) -> str:
+        return self._asset_rid
+
+    @builtins.property
+    def data_scope_name(self) -> str:
+        return self._data_scope_name
+
+    @builtins.property
+    def channel(self) -> str:
+        return self._channel
+
+    @builtins.property
+    def tags(self) -> Dict[str, str]:
+        return self._tags
+
+
+scout_video_api_VideoAssetChannel.__name__ = "VideoAssetChannel"
+scout_video_api_VideoAssetChannel.__qualname__ = "VideoAssetChannel"
+scout_video_api_VideoAssetChannel.__module__ = "nominal_api.scout_video_api"
+
+
+class scout_video_api_VideoChannelSeries(ConjureUnionType):
+    """Union type for referencing a video channel. Allows querying video data via 
+datasource/channel, asset data scopes, or run data scopes.
+    """
+    _data_source: Optional["scout_video_api_VideoDataSourceChannel"] = None
+    _asset: Optional["scout_video_api_VideoAssetChannel"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'data_source': ConjureFieldDefinition('dataSource', scout_video_api_VideoDataSourceChannel),
+            'asset': ConjureFieldDefinition('asset', scout_video_api_VideoAssetChannel)
+        }
+
+    def __init__(
+            self,
+            data_source: Optional["scout_video_api_VideoDataSourceChannel"] = None,
+            asset: Optional["scout_video_api_VideoAssetChannel"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (data_source is not None) + (asset is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if data_source is not None:
+                self._data_source = data_source
+                self._type = 'dataSource'
+            if asset is not None:
+                self._asset = asset
+                self._type = 'asset'
+
+        elif type_of_union == 'dataSource':
+            if data_source is None:
+                raise ValueError('a union value must not be None')
+            self._data_source = data_source
+            self._type = 'dataSource'
+        elif type_of_union == 'asset':
+            if asset is None:
+                raise ValueError('a union value must not be None')
+            self._asset = asset
+            self._type = 'asset'
+
+    @builtins.property
+    def data_source(self) -> Optional["scout_video_api_VideoDataSourceChannel"]:
+        return self._data_source
+
+    @builtins.property
+    def asset(self) -> Optional["scout_video_api_VideoAssetChannel"]:
+        return self._asset
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_video_api_VideoChannelSeriesVisitor):
+            raise ValueError('{} is not an instance of scout_video_api_VideoChannelSeriesVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'dataSource' and self.data_source is not None:
+            return visitor._data_source(self.data_source)
+        if self._type == 'asset' and self.asset is not None:
+            return visitor._asset(self.asset)
+
+
+scout_video_api_VideoChannelSeries.__name__ = "VideoChannelSeries"
+scout_video_api_VideoChannelSeries.__qualname__ = "VideoChannelSeries"
+scout_video_api_VideoChannelSeries.__module__ = "nominal_api.scout_video_api"
+
+
+class scout_video_api_VideoChannelSeriesVisitor:
+
+    @abstractmethod
+    def _data_source(self, data_source: "scout_video_api_VideoDataSourceChannel") -> Any:
+        pass
+
+    @abstractmethod
+    def _asset(self, asset: "scout_video_api_VideoAssetChannel") -> Any:
+        pass
+
+
+scout_video_api_VideoChannelSeriesVisitor.__name__ = "VideoChannelSeriesVisitor"
+scout_video_api_VideoChannelSeriesVisitor.__qualname__ = "VideoChannelSeriesVisitor"
+scout_video_api_VideoChannelSeriesVisitor.__module__ = "nominal_api.scout_video_api"
+
+
+class scout_video_api_VideoDataSourceChannel(ConjureBeanType):
+    """Reference a video channel directly from a datasource/dataset
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'data_source_rid': ConjureFieldDefinition('dataSourceRid', str),
+            'channel': ConjureFieldDefinition('channel', str),
+            'tags': ConjureFieldDefinition('tags', Dict[api_TagName, api_TagValue])
+        }
+
+    __slots__: List[str] = ['_data_source_rid', '_channel', '_tags']
+
+    def __init__(self, channel: str, data_source_rid: str, tags: Dict[str, str]) -> None:
+        self._data_source_rid = data_source_rid
+        self._channel = channel
+        self._tags = tags
+
+    @builtins.property
+    def data_source_rid(self) -> str:
+        return self._data_source_rid
+
+    @builtins.property
+    def channel(self) -> str:
+        return self._channel
+
+    @builtins.property
+    def tags(self) -> Dict[str, str]:
+        return self._tags
+
+
+scout_video_api_VideoDataSourceChannel.__name__ = "VideoDataSourceChannel"
+scout_video_api_VideoDataSourceChannel.__qualname__ = "VideoDataSourceChannel"
+scout_video_api_VideoDataSourceChannel.__module__ = "nominal_api.scout_video_api"
+
+
 class scout_video_api_VideoFile(ConjureBeanType):
     """Representation of a single user-provided video file.
     """
@@ -97280,6 +98121,7 @@ message Points {
     IntegerPoints integer_points = 3;
     ArrayPoints array_points = 4;
     StructPoints struct_points = 5;
+    Uint64Points uint64_points = 6;
   }
 }
 
@@ -97295,6 +98137,10 @@ message IntegerPoints {
   repeated IntegerPoint points = 1;
 }
 
+message Uint64Points {
+  repeated Uint64Point points = 1;
+}
+
 message ArrayPoints {
   oneof array_type {
     DoubleArrayPoints double_array_points = 1;
@@ -97329,6 +98175,11 @@ message IntegerPoint {
   int64 value = 2;
 }
 
+message Uint64Point {
+  google.protobuf.Timestamp timestamp = 1;
+  uint64 value = 2;
+}
+
 message DoubleArrayPoint {
   google.protobuf.Timestamp timestamp = 1;
   repeated double value = 2;
@@ -97431,6 +98282,7 @@ Logs specifically are supported externally via a separate endpoint.
     _double: Optional[List["storage_writer_api_DoublePoint"]] = None
     _log: Optional[List["storage_writer_api_LogPoint"]] = None
     _int_: Optional[List["storage_writer_api_IntPoint"]] = None
+    _uint64: Optional[List["storage_writer_api_Uint64Point"]] = None
     _array: Optional["storage_writer_api_ArrayPoints"] = None
     _struct: Optional[List["storage_writer_api_StructPoint"]] = None
 
@@ -97441,6 +98293,7 @@ Logs specifically are supported externally via a separate endpoint.
             'double': ConjureFieldDefinition('double', List[storage_writer_api_DoublePoint]),
             'log': ConjureFieldDefinition('log', List[storage_writer_api_LogPoint]),
             'int_': ConjureFieldDefinition('int', List[storage_writer_api_IntPoint]),
+            'uint64': ConjureFieldDefinition('uint64', List[storage_writer_api_Uint64Point]),
             'array': ConjureFieldDefinition('array', storage_writer_api_ArrayPoints),
             'struct': ConjureFieldDefinition('struct', List[storage_writer_api_StructPoint])
         }
@@ -97451,12 +98304,13 @@ Logs specifically are supported externally via a separate endpoint.
             double: Optional[List["storage_writer_api_DoublePoint"]] = None,
             log: Optional[List["storage_writer_api_LogPoint"]] = None,
             int_: Optional[List["storage_writer_api_IntPoint"]] = None,
+            uint64: Optional[List["storage_writer_api_Uint64Point"]] = None,
             array: Optional["storage_writer_api_ArrayPoints"] = None,
             struct: Optional[List["storage_writer_api_StructPoint"]] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (string is not None) + (double is not None) + (log is not None) + (int_ is not None) + (array is not None) + (struct is not None) != 1:
+            if (string is not None) + (double is not None) + (log is not None) + (int_ is not None) + (uint64 is not None) + (array is not None) + (struct is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if string is not None:
@@ -97471,6 +98325,9 @@ Logs specifically are supported externally via a separate endpoint.
             if int_ is not None:
                 self._int_ = int_
                 self._type = 'int'
+            if uint64 is not None:
+                self._uint64 = uint64
+                self._type = 'uint64'
             if array is not None:
                 self._array = array
                 self._type = 'array'
@@ -97498,6 +98355,11 @@ Logs specifically are supported externally via a separate endpoint.
                 raise ValueError('a union value must not be None')
             self._int_ = int_
             self._type = 'int'
+        elif type_of_union == 'uint64':
+            if uint64 is None:
+                raise ValueError('a union value must not be None')
+            self._uint64 = uint64
+            self._type = 'uint64'
         elif type_of_union == 'array':
             if array is None:
                 raise ValueError('a union value must not be None')
@@ -97525,6 +98387,10 @@ Logs specifically are supported externally via a separate endpoint.
     def int_(self) -> Optional[List["storage_writer_api_IntPoint"]]:
         return self._int_
 
+    @builtins.property
+    def uint64(self) -> Optional[List["storage_writer_api_Uint64Point"]]:
+        return self._uint64
+
     @builtins.property
     def array(self) -> Optional["storage_writer_api_ArrayPoints"]:
         return self._array
@@ -97544,6 +98410,8 @@ Logs specifically are supported externally via a separate endpoint.
             return visitor._log(self.log)
         if self._type == 'int' and self.int_ is not None:
             return visitor._int(self.int_)
+        if self._type == 'uint64' and self.uint64 is not None:
+            return visitor._uint64(self.uint64)
         if self._type == 'array' and self.array is not None:
             return visitor._array(self.array)
         if self._type == 'struct' and self.struct is not None:
@@ -97573,6 +98441,10 @@ class storage_writer_api_PointsVisitor:
     def _int(self, int_: List["storage_writer_api_IntPoint"]) -> Any:
         pass
 
+    @abstractmethod
+    def _uint64(self, uint64: List["storage_writer_api_Uint64Point"]) -> Any:
+        pass
+
     @abstractmethod
     def _array(self, array: "storage_writer_api_ArrayPoints") -> Any:
         pass
@@ -97929,6 +98801,35 @@ storage_writer_api_TelegrafMetric.__qualname__ = "TelegrafMetric"
 storage_writer_api_TelegrafMetric.__module__ = "nominal_api.storage_writer_api"
 
 
+class storage_writer_api_Uint64Point(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'timestamp': ConjureFieldDefinition('timestamp', api_Timestamp),
+            'value': ConjureFieldDefinition('value', int)
+        }
+
+    __slots__: List[str] = ['_timestamp', '_value']
+
+    def __init__(self, timestamp: "api_Timestamp", value: int) -> None:
+        self._timestamp = timestamp
+        self._value = value
+
+    @builtins.property
+    def timestamp(self) -> "api_Timestamp":
+        return self._timestamp
+
+    @builtins.property
+    def value(self) -> int:
+        return self._value
+
+
+storage_writer_api_Uint64Point.__name__ = "Uint64Point"
+storage_writer_api_Uint64Point.__qualname__ = "Uint64Point"
+storage_writer_api_Uint64Point.__module__ = "nominal_api.storage_writer_api"
+
+
 class storage_writer_api_WriteBatchesRequest(ConjureBeanType):
 
     @builtins.classmethod