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

nominal_api/_impl.py

@@ -4244,6 +4244,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
@@ -25932,12 +26033,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 +26053,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 +26114,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'
@@ -44057,62 +44224,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 +44921,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 +44934,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 +44947,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 +44978,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 +45022,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 +45060,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 +45083,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 +45126,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 +45441,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 +45473,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 +45505,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 +45517,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 +45577,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 +45700,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 +45822,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 +45899,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 +46002,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 +49864,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 +50333,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 +57485,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 +57945,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 +63509,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 +63723,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 +66522,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 +66535,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 +66548,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 +66579,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 +66623,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 +66661,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 +66684,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 +66727,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 +67935,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 +74770,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 +76181,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 +77728,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 +77880,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 +77897,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 +77916,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 +77931,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 +77952,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 +78039,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 +78085,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 +78196,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 +78214,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 +78231,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 +78253,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 +78276,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 +78293,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 +78318,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"
@@ -78724,50 +78456,148 @@ class scout_integrations_api_IntegrationsService(Service):
         _path = _path.format(**_path_params)
 
         _response: Response = self._request(
-            'DELETE',
+            'DELETE',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        return
+
+    def update_integration_metadata(self, auth_header: str, integration_rid: str, request: "scout_integrations_api_UpdateIntegrationRequest") -> "scout_integrations_api_Integration":
+        """Updates the metadata of an integration.
+        """
+        _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] = {
+            'integrationRid': quote(str(_conjure_encoder.default(integration_rid)), safe=''),
+        }
+
+        _json: Any = _conjure_encoder.default(request)
+
+        _path = '/scout/v2/integrations/{integrationRid}'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'PUT',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        _decoder = ConjureDecoder()
+        return _decoder.decode(_response.json(), scout_integrations_api_Integration, self._return_none_for_unknown_union_types)
+
+    def update_integration_details(self, auth_header: str, integration_rid: str, request: "scout_integrations_api_UpdateIntegrationDetailsRequest") -> "scout_integrations_api_Integration":
+        """Updates the integration details for an integration.
+Intended to allow changing webhooks or rotating API keys.
+        """
+        _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] = {
+            'integrationRid': quote(str(_conjure_encoder.default(integration_rid)), safe=''),
+        }
+
+        _json: Any = _conjure_encoder.default(request)
+
+        _path = '/scout/v2/integrations/{integrationRid}/details'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'PUT',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        _decoder = ConjureDecoder()
+        return _decoder.decode(_response.json(), scout_integrations_api_Integration, self._return_none_for_unknown_union_types)
+
+    def get_integration(self, auth_header: str, integration_rid: str) -> "scout_integrations_api_Integration":
+        """Retrieves an integration with the specified integration RID.
+        """
+        _conjure_encoder = ConjureEncoder()
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, str] = {
+            'integrationRid': quote(str(_conjure_encoder.default(integration_rid)), safe=''),
+        }
+
+        _json: Any = None
+
+        _path = '/scout/v2/integrations/{integrationRid}'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'GET',
             self._uri + _path,
             params=_params,
             headers=_headers,
             json=_json)
 
-        return
+        _decoder = ConjureDecoder()
+        return _decoder.decode(_response.json(), scout_integrations_api_Integration, self._return_none_for_unknown_union_types)
 
-    def update_integration_metadata(self, auth_header: str, integration_rid: str, request: "scout_integrations_api_UpdateIntegrationRequest") -> "scout_integrations_api_Integration":
-        """Updates the metadata of an integration.
+    def list_integrations(self, auth_header: str, workspaces: List[str] = None) -> List["scout_integrations_api_Integration"]:
+        """Lists all integrations. Archived integrations are not included.
         """
+        workspaces = workspaces if workspaces is not None else []
         _conjure_encoder = ConjureEncoder()
 
         _headers: Dict[str, Any] = {
             'Accept': 'application/json',
-            'Content-Type': 'application/json',
             'Authorization': auth_header,
         }
 
         _params: Dict[str, Any] = {
+            'workspaces': _conjure_encoder.default(workspaces),
         }
 
         _path_params: Dict[str, str] = {
-            'integrationRid': quote(str(_conjure_encoder.default(integration_rid)), safe=''),
         }
 
-        _json: Any = _conjure_encoder.default(request)
+        _json: Any = None
 
-        _path = '/scout/v2/integrations/{integrationRid}'
+        _path = '/scout/v2/integrations/list'
         _path = _path.format(**_path_params)
 
         _response: Response = self._request(
-            'PUT',
+            'GET',
             self._uri + _path,
             params=_params,
             headers=_headers,
             json=_json)
 
         _decoder = ConjureDecoder()
-        return _decoder.decode(_response.json(), scout_integrations_api_Integration, self._return_none_for_unknown_union_types)
+        return _decoder.decode(_response.json(), List[scout_integrations_api_Integration], self._return_none_for_unknown_union_types)
 
-    def update_integration_details(self, auth_header: str, integration_rid: str, request: "scout_integrations_api_UpdateIntegrationDetailsRequest") -> "scout_integrations_api_Integration":
-        """Updates the integration details for an integration.
-Intended to allow changing webhooks or rotating API keys.
+    def send_message(self, auth_header: str, request: "scout_integrations_api_SendMessageRequest") -> None:
+        """Sends a string message to the specified integration from a checklist execution.
         """
         _conjure_encoder = ConjureEncoder()
 
@@ -78781,124 +78611,132 @@ Intended to allow changing webhooks or rotating API keys.
         }
 
         _path_params: Dict[str, str] = {
-            'integrationRid': quote(str(_conjure_encoder.default(integration_rid)), safe=''),
         }
 
         _json: Any = _conjure_encoder.default(request)
 
-        _path = '/scout/v2/integrations/{integrationRid}/details'
+        _path = '/scout/v2/integrations/send-message'
         _path = _path.format(**_path_params)
 
         _response: Response = self._request(
-            'PUT',
+            'POST',
             self._uri + _path,
             params=_params,
             headers=_headers,
             json=_json)
 
-        _decoder = ConjureDecoder()
-        return _decoder.decode(_response.json(), scout_integrations_api_Integration, self._return_none_for_unknown_union_types)
+        return
 
-    def get_integration(self, auth_header: str, integration_rid: str) -> "scout_integrations_api_Integration":
-        """Retrieves an integration with the specified integration RID.
-        """
-        _conjure_encoder = ConjureEncoder()
 
-        _headers: Dict[str, Any] = {
-            'Accept': 'application/json',
-            'Authorization': auth_header,
-        }
+scout_integrations_api_IntegrationsService.__name__ = "IntegrationsService"
+scout_integrations_api_IntegrationsService.__qualname__ = "IntegrationsService"
+scout_integrations_api_IntegrationsService.__module__ = "nominal_api.scout_integrations_api"
 
-        _params: Dict[str, Any] = {
-        }
 
-        _path_params: Dict[str, str] = {
-            'integrationRid': quote(str(_conjure_encoder.default(integration_rid)), safe=''),
+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)
         }
 
-        _json: Any = None
+    __slots__: List[str] = ['_integration_rid', '_message']
 
-        _path = '/scout/v2/integrations/{integrationRid}'
-        _path = _path.format(**_path_params)
+    def __init__(self, integration_rid: str, message: "scout_integrations_api_MessageFields") -> None:
+        self._integration_rid = integration_rid
+        self._message = message
 
-        _response: Response = self._request(
-            'GET',
-            self._uri + _path,
-            params=_params,
-            headers=_headers,
-            json=_json)
+    @builtins.property
+    def integration_rid(self) -> str:
+        return self._integration_rid
 
-        _decoder = ConjureDecoder()
-        return _decoder.decode(_response.json(), scout_integrations_api_Integration, self._return_none_for_unknown_union_types)
+    @builtins.property
+    def message(self) -> "scout_integrations_api_MessageFields":
+        return self._message
 
-    def list_integrations(self, auth_header: str, workspaces: List[str] = None) -> List["scout_integrations_api_Integration"]:
-        """Lists all integrations. Archived integrations are not included.
-        """
-        workspaces = workspaces if workspaces is not None else []
-        _conjure_encoder = ConjureEncoder()
 
-        _headers: Dict[str, Any] = {
-            'Accept': 'application/json',
-            'Authorization': auth_header,
-        }
+scout_integrations_api_InternalSendMessageRequest.__name__ = "InternalSendMessageRequest"
+scout_integrations_api_InternalSendMessageRequest.__qualname__ = "InternalSendMessageRequest"
+scout_integrations_api_InternalSendMessageRequest.__module__ = "nominal_api.scout_integrations_api"
 
-        _params: Dict[str, Any] = {
-            'workspaces': _conjure_encoder.default(workspaces),
-        }
 
-        _path_params: Dict[str, str] = {
+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)
         }
 
-        _json: Any = None
+    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')
 
-        _path = '/scout/v2/integrations/list'
-        _path = _path.format(**_path_params)
+            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'
 
-        _response: Response = self._request(
-            'GET',
-            self._uri + _path,
-            params=_params,
-            headers=_headers,
-            json=_json)
+        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'
 
-        _decoder = ConjureDecoder()
-        return _decoder.decode(_response.json(), List[scout_integrations_api_Integration], self._return_none_for_unknown_union_types)
+    @builtins.property
+    def alert(self) -> Optional["scout_integrations_api_AlertMessageFields"]:
+        return self._alert
 
-    def send_message(self, auth_header: str, request: "scout_integrations_api_SendMessageRequest") -> None:
-        """Sends a string message to the specified integration from a checklist execution.
-        """
-        _conjure_encoder = ConjureEncoder()
+    @builtins.property
+    def resolution_error(self) -> Optional["scout_integrations_api_ResolutionFailureMessageFields"]:
+        return self._resolution_error
 
-        _headers: Dict[str, Any] = {
-            'Accept': 'application/json',
-            'Content-Type': 'application/json',
-            'Authorization': auth_header,
-        }
+    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)
 
-        _params: Dict[str, Any] = {
-        }
 
-        _path_params: Dict[str, str] = {
-        }
+scout_integrations_api_MessageFields.__name__ = "MessageFields"
+scout_integrations_api_MessageFields.__qualname__ = "MessageFields"
+scout_integrations_api_MessageFields.__module__ = "nominal_api.scout_integrations_api"
 
-        _json: Any = _conjure_encoder.default(request)
 
-        _path = '/scout/v2/integrations/send-message'
-        _path = _path.format(**_path_params)
+class scout_integrations_api_MessageFieldsVisitor:
 
-        _response: Response = self._request(
-            'POST',
-            self._uri + _path,
-            params=_params,
-            headers=_headers,
-            json=_json)
+    @abstractmethod
+    def _alert(self, alert: "scout_integrations_api_AlertMessageFields") -> Any:
+        pass
 
-        return
+    @abstractmethod
+    def _resolution_error(self, resolution_error: "scout_integrations_api_ResolutionFailureMessageFields") -> Any:
+        pass
 
 
-scout_integrations_api_IntegrationsService.__name__ = "IntegrationsService"
-scout_integrations_api_IntegrationsService.__qualname__ = "IntegrationsService"
-scout_integrations_api_IntegrationsService.__module__ = "nominal_api.scout_integrations_api"
+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):
@@ -79011,6 +78849,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 +79060,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 +79109,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 +79126,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 +79145,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 +79160,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 +79181,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 +79279,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 +79325,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 +81563,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 +81581,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 +81627,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 +86487,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 +86515,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 +86529,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 +86554,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 +86570,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 +86798,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
 
@@ -90826,6 +90845,41 @@ 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_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 +90914,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 +91697,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 +91787,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 +93098,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 +97591,7 @@ message Points {
     IntegerPoints integer_points = 3;
     ArrayPoints array_points = 4;
     StructPoints struct_points = 5;
+    Uint64Points uint64_points = 6;
   }
 }
 
@@ -97295,6 +97607,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 +97645,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 +97752,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 +97763,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 +97774,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 +97795,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 +97825,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 +97857,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 +97880,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 +97911,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 +98271,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