nominal-api 0.561.2__py3-none-any.whl → 0.563.0__py3-none-any.whl

nominal_api/__init__.py

@@ -69,5 +69,5 @@ __all__ = [
 
 __conjure_generator_version__ = "4.9.0"
 
-__version__ = "0.561.2"
+__version__ = "0.563.0"
 

nominal_api/_impl.py

@@ -29056,7 +29056,7 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
     _range: Optional[List["scout_compute_api_Range"]] = None
     _ranges_summary: Optional["scout_compute_api_RangesSummary"] = None
     _enum: Optional["scout_compute_api_EnumPlot"] = None
-    _log: Optional["scout_compute_api_LogPlot"] = None
+    _paged_log: Optional["scout_compute_api_PagedLogPlot"] = None
     _bucketed_enum: Optional["scout_compute_api_BucketedEnumPlot"] = None
     _cartesian: Optional["scout_compute_api_CartesianPlot"] = None
     _bucketed_cartesian: Optional["scout_compute_api_BucketedCartesianPlot"] = None
@@ -29077,7 +29077,7 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
             'range': ConjureFieldDefinition('range', List[scout_compute_api_Range]),
             'ranges_summary': ConjureFieldDefinition('rangesSummary', scout_compute_api_RangesSummary),
             'enum': ConjureFieldDefinition('enum', scout_compute_api_EnumPlot),
-            'log': ConjureFieldDefinition('log', scout_compute_api_LogPlot),
+            'paged_log': ConjureFieldDefinition('pagedLog', scout_compute_api_PagedLogPlot),
             'bucketed_enum': ConjureFieldDefinition('bucketedEnum', scout_compute_api_BucketedEnumPlot),
             'cartesian': ConjureFieldDefinition('cartesian', scout_compute_api_CartesianPlot),
             'bucketed_cartesian': ConjureFieldDefinition('bucketedCartesian', scout_compute_api_BucketedCartesianPlot),
@@ -29098,7 +29098,7 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
             range: Optional[List["scout_compute_api_Range"]] = None,
             ranges_summary: Optional["scout_compute_api_RangesSummary"] = None,
             enum: Optional["scout_compute_api_EnumPlot"] = None,
-            log: Optional["scout_compute_api_LogPlot"] = None,
+            paged_log: Optional["scout_compute_api_PagedLogPlot"] = None,
             bucketed_enum: Optional["scout_compute_api_BucketedEnumPlot"] = None,
             cartesian: Optional["scout_compute_api_CartesianPlot"] = None,
             bucketed_cartesian: Optional["scout_compute_api_BucketedCartesianPlot"] = None,
@@ -29113,7 +29113,7 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (numeric is not None) + (bucketed_numeric is not None) + (range is not None) + (ranges_summary is not None) + (enum is not None) + (log is not None) + (bucketed_enum is not None) + (cartesian is not None) + (bucketed_cartesian is not None) + (bucketed_geo is not None) + (enum_point is not None) + (numeric_point is not None) + (log_point is not None) + (range_value is not None) + (frequency_domain is not None) + (numeric_histogram is not None) + (enum_histogram is not None) != 1:
+            if (numeric is not None) + (bucketed_numeric is not None) + (range is not None) + (ranges_summary is not None) + (enum is not None) + (paged_log is not None) + (bucketed_enum is not None) + (cartesian is not None) + (bucketed_cartesian is not None) + (bucketed_geo is not None) + (enum_point is not None) + (numeric_point is not None) + (log_point is not None) + (range_value is not None) + (frequency_domain is not None) + (numeric_histogram is not None) + (enum_histogram is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if numeric is not None:
@@ -29131,9 +29131,9 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
             if enum is not None:
                 self._enum = enum
                 self._type = 'enum'
-            if log is not None:
-                self._log = log
-                self._type = 'log'
+            if paged_log is not None:
+                self._paged_log = paged_log
+                self._type = 'pagedLog'
             if bucketed_enum is not None:
                 self._bucketed_enum = bucketed_enum
                 self._type = 'bucketedEnum'
@@ -29193,11 +29193,11 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._enum = enum
             self._type = 'enum'
-        elif type_of_union == 'log':
-            if log is None:
+        elif type_of_union == 'pagedLog':
+            if paged_log is None:
                 raise ValueError('a union value must not be None')
-            self._log = log
-            self._type = 'log'
+            self._paged_log = paged_log
+            self._type = 'pagedLog'
         elif type_of_union == 'bucketedEnum':
             if bucketed_enum is None:
                 raise ValueError('a union value must not be None')
@@ -29275,8 +29275,8 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
         return self._enum
 
     @builtins.property
-    def log(self) -> Optional["scout_compute_api_LogPlot"]:
-        return self._log
+    def paged_log(self) -> Optional["scout_compute_api_PagedLogPlot"]:
+        return self._paged_log
 
     @builtins.property
     def bucketed_enum(self) -> Optional["scout_compute_api_BucketedEnumPlot"]:
@@ -29335,8 +29335,8 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
             return visitor._ranges_summary(self.ranges_summary)
         if self._type == 'enum' and self.enum is not None:
             return visitor._enum(self.enum)
-        if self._type == 'log' and self.log is not None:
-            return visitor._log(self.log)
+        if self._type == 'pagedLog' and self.paged_log is not None:
+            return visitor._paged_log(self.paged_log)
         if self._type == 'bucketedEnum' and self.bucketed_enum is not None:
             return visitor._bucketed_enum(self.bucketed_enum)
         if self._type == 'cartesian' and self.cartesian is not None:
@@ -29389,7 +29389,7 @@ class scout_compute_api_ComputeNodeResponseVisitor:
         pass
 
     @abstractmethod
-    def _log(self, log: "scout_compute_api_LogPlot") -> Any:
+    def _paged_log(self, paged_log: "scout_compute_api_PagedLogPlot") -> Any:
         pass
 
     @abstractmethod
@@ -32376,35 +32376,6 @@ scout_compute_api_LogFilterSeries.__qualname__ = "LogFilterSeries"
 scout_compute_api_LogFilterSeries.__module__ = "nominal_api.scout_compute_api"
 
 
-class scout_compute_api_LogPlot(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'timestamps': ConjureFieldDefinition('timestamps', List[api_Timestamp]),
-            'values': ConjureFieldDefinition('values', List[scout_compute_api_LogValue])
-        }
-
-    __slots__: List[str] = ['_timestamps', '_values']
-
-    def __init__(self, timestamps: List["api_Timestamp"], values: List["scout_compute_api_LogValue"]) -> None:
-        self._timestamps = timestamps
-        self._values = values
-
-    @builtins.property
-    def timestamps(self) -> List["api_Timestamp"]:
-        return self._timestamps
-
-    @builtins.property
-    def values(self) -> List["scout_compute_api_LogValue"]:
-        return self._values
-
-
-scout_compute_api_LogPlot.__name__ = "LogPlot"
-scout_compute_api_LogPlot.__qualname__ = "LogPlot"
-scout_compute_api_LogPlot.__module__ = "nominal_api.scout_compute_api"
-
-
 class scout_compute_api_LogPoint(ConjureBeanType):
 
     @builtins.classmethod
@@ -32688,14 +32659,16 @@ class scout_compute_api_LogValue(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'message': ConjureFieldDefinition('message', str),
-            'args': ConjureFieldDefinition('args', Dict[str, str])
+            'args': ConjureFieldDefinition('args', Dict[str, str]),
+            'id': ConjureFieldDefinition('id', str)
         }
 
-    __slots__: List[str] = ['_message', '_args']
+    __slots__: List[str] = ['_message', '_args', '_id']
 
-    def __init__(self, args: Dict[str, str], message: str) -> None:
+    def __init__(self, args: Dict[str, str], id: str, message: str) -> None:
         self._message = message
         self._args = args
+        self._id = id
 
     @builtins.property
     def message(self) -> str:
@@ -32705,6 +32678,10 @@ class scout_compute_api_LogValue(ConjureBeanType):
     def args(self) -> Dict[str, str]:
         return self._args
 
+    @builtins.property
+    def id(self) -> str:
+        return self._id
+
 
 scout_compute_api_LogValue.__name__ = "LogValue"
 scout_compute_api_LogValue.__qualname__ = "LogValue"
@@ -34620,24 +34597,24 @@ scout_compute_api_OutputRangeStartVisitor.__module__ = "nominal_api.scout_comput
 class scout_compute_api_PageInfo(ConjureBeanType):
     """
     Specification of a page for a series. Returns raw undecimated points beginning nearest to the given page
-token timestamp, advancing pageSize points in the time direction specified by the sign of the page size.
+token, advancing pageSize points in the time direction specified by the sign of the page size.
     """
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'page_token': ConjureFieldDefinition('pageToken', api_Timestamp),
+            'page_token': ConjureFieldDefinition('pageToken', OptionalTypeWrapper[scout_compute_api_PageToken]),
             'page_size': ConjureFieldDefinition('pageSize', int)
         }
 
     __slots__: List[str] = ['_page_token', '_page_size']
 
-    def __init__(self, page_size: int, page_token: "api_Timestamp") -> None:
+    def __init__(self, page_size: int, page_token: Optional["scout_compute_api_PageToken"] = None) -> None:
         self._page_token = page_token
         self._page_size = page_size
 
     @builtins.property
-    def page_token(self) -> "api_Timestamp":
+    def page_token(self) -> Optional["scout_compute_api_PageToken"]:
         return self._page_token
 
     @builtins.property
@@ -34706,6 +34683,102 @@ scout_compute_api_PageStrategyVisitor.__qualname__ = "PageStrategyVisitor"
 scout_compute_api_PageStrategyVisitor.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_PageToken(ConjureUnionType):
+    _timestamp_and_id: Optional["scout_compute_api_TimestampAndId"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'timestamp_and_id': ConjureFieldDefinition('timestampAndId', scout_compute_api_TimestampAndId)
+        }
+
+    def __init__(
+            self,
+            timestamp_and_id: Optional["scout_compute_api_TimestampAndId"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (timestamp_and_id is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if timestamp_and_id is not None:
+                self._timestamp_and_id = timestamp_and_id
+                self._type = 'timestampAndId'
+
+        elif type_of_union == 'timestampAndId':
+            if timestamp_and_id is None:
+                raise ValueError('a union value must not be None')
+            self._timestamp_and_id = timestamp_and_id
+            self._type = 'timestampAndId'
+
+    @builtins.property
+    def timestamp_and_id(self) -> Optional["scout_compute_api_TimestampAndId"]:
+        return self._timestamp_and_id
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_compute_api_PageTokenVisitor):
+            raise ValueError('{} is not an instance of scout_compute_api_PageTokenVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'timestampAndId' and self.timestamp_and_id is not None:
+            return visitor._timestamp_and_id(self.timestamp_and_id)
+
+
+scout_compute_api_PageToken.__name__ = "PageToken"
+scout_compute_api_PageToken.__qualname__ = "PageToken"
+scout_compute_api_PageToken.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_PageTokenVisitor:
+
+    @abstractmethod
+    def _timestamp_and_id(self, timestamp_and_id: "scout_compute_api_TimestampAndId") -> Any:
+        pass
+
+
+scout_compute_api_PageTokenVisitor.__name__ = "PageTokenVisitor"
+scout_compute_api_PageTokenVisitor.__qualname__ = "PageTokenVisitor"
+scout_compute_api_PageTokenVisitor.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_PagedLogPlot(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'timestamps': ConjureFieldDefinition('timestamps', List[api_Timestamp]),
+            'values': ConjureFieldDefinition('values', List[scout_compute_api_LogValue]),
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[scout_compute_api_PageToken])
+        }
+
+    __slots__: List[str] = ['_timestamps', '_values', '_next_page_token']
+
+    def __init__(self, timestamps: List["api_Timestamp"], values: List["scout_compute_api_LogValue"], next_page_token: Optional["scout_compute_api_PageToken"] = None) -> None:
+        self._timestamps = timestamps
+        self._values = values
+        self._next_page_token = next_page_token
+
+    @builtins.property
+    def timestamps(self) -> List["api_Timestamp"]:
+        return self._timestamps
+
+    @builtins.property
+    def values(self) -> List["scout_compute_api_LogValue"]:
+        return self._values
+
+    @builtins.property
+    def next_page_token(self) -> Optional["scout_compute_api_PageToken"]:
+        """
+        The token to retrieve the next page of logs in the direction originally requested (exclusive - not
+included in these results). May be empty if there are no further logs in the requested time range in the
+direction originally requested.
+        """
+        return self._next_page_token
+
+
+scout_compute_api_PagedLogPlot.__name__ = "PagedLogPlot"
+scout_compute_api_PagedLogPlot.__qualname__ = "PagedLogPlot"
+scout_compute_api_PagedLogPlot.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_ParameterInput(ConjureBeanType):
 
     @builtins.classmethod
@@ -37651,6 +37724,35 @@ scout_compute_api_TimeDifferenceSeries.__qualname__ = "TimeDifferenceSeries"
 scout_compute_api_TimeDifferenceSeries.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_TimestampAndId(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'timestamp': ConjureFieldDefinition('timestamp', api_Timestamp),
+            'id': ConjureFieldDefinition('id', OptionalTypeWrapper[str])
+        }
+
+    __slots__: List[str] = ['_timestamp', '_id']
+
+    def __init__(self, timestamp: "api_Timestamp", id: Optional[str] = None) -> None:
+        self._timestamp = timestamp
+        self._id = id
+
+    @builtins.property
+    def timestamp(self) -> "api_Timestamp":
+        return self._timestamp
+
+    @builtins.property
+    def id(self) -> Optional[str]:
+        return self._id
+
+
+scout_compute_api_TimestampAndId.__name__ = "TimestampAndId"
+scout_compute_api_TimestampAndId.__qualname__ = "TimestampAndId"
+scout_compute_api_TimestampAndId.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_TimestampConstant(ConjureUnionType):
     _literal: Optional["api_Timestamp"] = None
     _variable: Optional[str] = None
@@ -42720,22 +42822,20 @@ scout_compute_resolved_api_LatLongGeoNode.__qualname__ = "LatLongGeoNode"
 scout_compute_resolved_api_LatLongGeoNode.__module__ = "nominal_api.scout_compute_resolved_api"
 
 
-class scout_compute_resolved_api_LogFilterRangesNode(ConjureBeanType):
+class scout_compute_resolved_api_LogFilterSeriesNode(ConjureBeanType):
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'input': ConjureFieldDefinition('input', scout_compute_resolved_api_LogSeriesNode),
-            'operator': ConjureFieldDefinition('operator', scout_compute_api_LogFilterOperator),
-            'persistence_window_configuration': ConjureFieldDefinition('persistenceWindowConfiguration', OptionalTypeWrapper[scout_compute_resolved_api_PersistenceWindowConfiguration])
+            'operator': ConjureFieldDefinition('operator', scout_compute_api_LogFilterOperator)
         }
 
-    __slots__: List[str] = ['_input', '_operator', '_persistence_window_configuration']
+    __slots__: List[str] = ['_input', '_operator']
 
-    def __init__(self, input: "scout_compute_resolved_api_LogSeriesNode", operator: "scout_compute_api_LogFilterOperator", persistence_window_configuration: Optional["scout_compute_resolved_api_PersistenceWindowConfiguration"] = None) -> None:
+    def __init__(self, input: "scout_compute_resolved_api_LogSeriesNode", operator: "scout_compute_api_LogFilterOperator") -> None:
         self._input = input
         self._operator = operator
-        self._persistence_window_configuration = persistence_window_configuration
 
     @builtins.property
     def input(self) -> "scout_compute_resolved_api_LogSeriesNode":
@@ -42745,52 +42845,16 @@ class scout_compute_resolved_api_LogFilterRangesNode(ConjureBeanType):
     def operator(self) -> "scout_compute_api_LogFilterOperator":
         return self._operator
 
-    @builtins.property
-    def persistence_window_configuration(self) -> Optional["scout_compute_resolved_api_PersistenceWindowConfiguration"]:
-        return self._persistence_window_configuration
-
-
-scout_compute_resolved_api_LogFilterRangesNode.__name__ = "LogFilterRangesNode"
-scout_compute_resolved_api_LogFilterRangesNode.__qualname__ = "LogFilterRangesNode"
-scout_compute_resolved_api_LogFilterRangesNode.__module__ = "nominal_api.scout_compute_resolved_api"
-
-
-class scout_compute_resolved_api_LogFilterTransformationSeriesNode(ConjureBeanType):
-    """
-    Outputs the values of the log plot value within the ranges specified by a ranges node
-    """
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'input': ConjureFieldDefinition('input', scout_compute_resolved_api_LogSeriesNode),
-            'filter': ConjureFieldDefinition('filter', scout_compute_resolved_api_RangesNode)
-        }
-
-    __slots__: List[str] = ['_input', '_filter']
-
-    def __init__(self, filter: "scout_compute_resolved_api_RangesNode", input: "scout_compute_resolved_api_LogSeriesNode") -> None:
-        self._input = input
-        self._filter = filter
-
-    @builtins.property
-    def input(self) -> "scout_compute_resolved_api_LogSeriesNode":
-        return self._input
-
-    @builtins.property
-    def filter(self) -> "scout_compute_resolved_api_RangesNode":
-        return self._filter
-
 
-scout_compute_resolved_api_LogFilterTransformationSeriesNode.__name__ = "LogFilterTransformationSeriesNode"
-scout_compute_resolved_api_LogFilterTransformationSeriesNode.__qualname__ = "LogFilterTransformationSeriesNode"
-scout_compute_resolved_api_LogFilterTransformationSeriesNode.__module__ = "nominal_api.scout_compute_resolved_api"
+scout_compute_resolved_api_LogFilterSeriesNode.__name__ = "LogFilterSeriesNode"
+scout_compute_resolved_api_LogFilterSeriesNode.__qualname__ = "LogFilterSeriesNode"
+scout_compute_resolved_api_LogFilterSeriesNode.__module__ = "nominal_api.scout_compute_resolved_api"
 
 
 class scout_compute_resolved_api_LogSeriesNode(ConjureUnionType):
     _raw: Optional["scout_compute_resolved_api_RawLogSeriesNode"] = None
     _union: Optional["scout_compute_resolved_api_LogUnionSeriesNode"] = None
-    _filter_transformation: Optional["scout_compute_resolved_api_LogFilterTransformationSeriesNode"] = None
+    _filter: Optional["scout_compute_resolved_api_LogFilterSeriesNode"] = None
     _time_shift: Optional["scout_compute_resolved_api_LogTimeShiftSeriesNode"] = None
 
     @builtins.classmethod
@@ -42798,7 +42862,7 @@ class scout_compute_resolved_api_LogSeriesNode(ConjureUnionType):
         return {
             'raw': ConjureFieldDefinition('raw', scout_compute_resolved_api_RawLogSeriesNode),
             'union': ConjureFieldDefinition('union', scout_compute_resolved_api_LogUnionSeriesNode),
-            'filter_transformation': ConjureFieldDefinition('filterTransformation', scout_compute_resolved_api_LogFilterTransformationSeriesNode),
+            'filter': ConjureFieldDefinition('filter', scout_compute_resolved_api_LogFilterSeriesNode),
             'time_shift': ConjureFieldDefinition('timeShift', scout_compute_resolved_api_LogTimeShiftSeriesNode)
         }
 
@@ -42806,12 +42870,12 @@ class scout_compute_resolved_api_LogSeriesNode(ConjureUnionType):
             self,
             raw: Optional["scout_compute_resolved_api_RawLogSeriesNode"] = None,
             union: Optional["scout_compute_resolved_api_LogUnionSeriesNode"] = None,
-            filter_transformation: Optional["scout_compute_resolved_api_LogFilterTransformationSeriesNode"] = None,
+            filter: Optional["scout_compute_resolved_api_LogFilterSeriesNode"] = None,
             time_shift: Optional["scout_compute_resolved_api_LogTimeShiftSeriesNode"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (raw is not None) + (union is not None) + (filter_transformation is not None) + (time_shift is not None) != 1:
+            if (raw is not None) + (union is not None) + (filter is not None) + (time_shift is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if raw is not None:
@@ -42820,9 +42884,9 @@ class scout_compute_resolved_api_LogSeriesNode(ConjureUnionType):
             if union is not None:
                 self._union = union
                 self._type = 'union'
-            if filter_transformation is not None:
-                self._filter_transformation = filter_transformation
-                self._type = 'filterTransformation'
+            if filter is not None:
+                self._filter = filter
+                self._type = 'filter'
             if time_shift is not None:
                 self._time_shift = time_shift
                 self._type = 'timeShift'
@@ -42837,11 +42901,11 @@ class scout_compute_resolved_api_LogSeriesNode(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._union = union
             self._type = 'union'
-        elif type_of_union == 'filterTransformation':
-            if filter_transformation is None:
+        elif type_of_union == 'filter':
+            if filter is None:
                 raise ValueError('a union value must not be None')
-            self._filter_transformation = filter_transformation
-            self._type = 'filterTransformation'
+            self._filter = filter
+            self._type = 'filter'
         elif type_of_union == 'timeShift':
             if time_shift is None:
                 raise ValueError('a union value must not be None')
@@ -42857,8 +42921,8 @@ class scout_compute_resolved_api_LogSeriesNode(ConjureUnionType):
         return self._union
 
     @builtins.property
-    def filter_transformation(self) -> Optional["scout_compute_resolved_api_LogFilterTransformationSeriesNode"]:
-        return self._filter_transformation
+    def filter(self) -> Optional["scout_compute_resolved_api_LogFilterSeriesNode"]:
+        return self._filter
 
     @builtins.property
     def time_shift(self) -> Optional["scout_compute_resolved_api_LogTimeShiftSeriesNode"]:
@@ -42871,8 +42935,8 @@ class scout_compute_resolved_api_LogSeriesNode(ConjureUnionType):
             return visitor._raw(self.raw)
         if self._type == 'union' and self.union is not None:
             return visitor._union(self.union)
-        if self._type == 'filterTransformation' and self.filter_transformation is not None:
-            return visitor._filter_transformation(self.filter_transformation)
+        if self._type == 'filter' and self.filter is not None:
+            return visitor._filter(self.filter)
         if self._type == 'timeShift' and self.time_shift is not None:
             return visitor._time_shift(self.time_shift)
 
@@ -42893,7 +42957,7 @@ class scout_compute_resolved_api_LogSeriesNodeVisitor:
         pass
 
     @abstractmethod
-    def _filter_transformation(self, filter_transformation: "scout_compute_resolved_api_LogFilterTransformationSeriesNode") -> Any:
+    def _filter(self, filter: "scout_compute_resolved_api_LogFilterSeriesNode") -> Any:
         pass
 
     @abstractmethod
@@ -44179,7 +44243,6 @@ class scout_compute_resolved_api_RangesNode(ConjureUnionType):
     _enum_filter: Optional["scout_compute_resolved_api_EnumFilterRangesNode"] = None
     _extrema: Optional["scout_compute_resolved_api_ExtremaRangesNode"] = None
     _intersect_range: Optional["scout_compute_resolved_api_IntersectRangesNode"] = None
-    _log_filter: Optional["scout_compute_resolved_api_LogFilterRangesNode"] = None
     _min_max_threshold: Optional["scout_compute_resolved_api_MinMaxThresholdRangesNode"] = None
     _not_: Optional["scout_compute_resolved_api_NotRangesNode"] = None
     _on_change: Optional["scout_compute_resolved_api_OnChangeRangesNode"] = None
@@ -44197,7 +44260,6 @@ class scout_compute_resolved_api_RangesNode(ConjureUnionType):
             'enum_filter': ConjureFieldDefinition('enumFilter', scout_compute_resolved_api_EnumFilterRangesNode),
             'extrema': ConjureFieldDefinition('extrema', scout_compute_resolved_api_ExtremaRangesNode),
             'intersect_range': ConjureFieldDefinition('intersectRange', scout_compute_resolved_api_IntersectRangesNode),
-            'log_filter': ConjureFieldDefinition('logFilter', scout_compute_resolved_api_LogFilterRangesNode),
             'min_max_threshold': ConjureFieldDefinition('minMaxThreshold', scout_compute_resolved_api_MinMaxThresholdRangesNode),
             'not_': ConjureFieldDefinition('not', scout_compute_resolved_api_NotRangesNode),
             'on_change': ConjureFieldDefinition('onChange', scout_compute_resolved_api_OnChangeRangesNode),
@@ -44215,7 +44277,6 @@ class scout_compute_resolved_api_RangesNode(ConjureUnionType):
             enum_filter: Optional["scout_compute_resolved_api_EnumFilterRangesNode"] = None,
             extrema: Optional["scout_compute_resolved_api_ExtremaRangesNode"] = None,
             intersect_range: Optional["scout_compute_resolved_api_IntersectRangesNode"] = None,
-            log_filter: Optional["scout_compute_resolved_api_LogFilterRangesNode"] = None,
             min_max_threshold: Optional["scout_compute_resolved_api_MinMaxThresholdRangesNode"] = None,
             not_: Optional["scout_compute_resolved_api_NotRangesNode"] = None,
             on_change: Optional["scout_compute_resolved_api_OnChangeRangesNode"] = None,
@@ -44228,7 +44289,7 @@ class scout_compute_resolved_api_RangesNode(ConjureUnionType):
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (enum_equality is not None) + (enum_filter is not None) + (extrema is not None) + (intersect_range is not None) + (log_filter is not None) + (min_max_threshold is not None) + (not_ is not None) + (on_change is not None) + (range_numeric_aggregation is not None) + (series_crossover_ranges_node is not None) + (stale_range is not None) + (stability_detection is not None) + (threshold is not None) + (union_range is not None) != 1:
+            if (enum_equality is not None) + (enum_filter is not None) + (extrema is not None) + (intersect_range is not None) + (min_max_threshold is not None) + (not_ is not None) + (on_change is not None) + (range_numeric_aggregation is not None) + (series_crossover_ranges_node is not None) + (stale_range is not None) + (stability_detection is not None) + (threshold is not None) + (union_range is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if enum_equality is not None:
@@ -44243,9 +44304,6 @@ class scout_compute_resolved_api_RangesNode(ConjureUnionType):
             if intersect_range is not None:
                 self._intersect_range = intersect_range
                 self._type = 'intersectRange'
-            if log_filter is not None:
-                self._log_filter = log_filter
-                self._type = 'logFilter'
             if min_max_threshold is not None:
                 self._min_max_threshold = min_max_threshold
                 self._type = 'minMaxThreshold'
@@ -44294,11 +44352,6 @@ class scout_compute_resolved_api_RangesNode(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._intersect_range = intersect_range
             self._type = 'intersectRange'
-        elif type_of_union == 'logFilter':
-            if log_filter is None:
-                raise ValueError('a union value must not be None')
-            self._log_filter = log_filter
-            self._type = 'logFilter'
         elif type_of_union == 'minMaxThreshold':
             if min_max_threshold is None:
                 raise ValueError('a union value must not be None')
@@ -44361,10 +44414,6 @@ class scout_compute_resolved_api_RangesNode(ConjureUnionType):
     def intersect_range(self) -> Optional["scout_compute_resolved_api_IntersectRangesNode"]:
         return self._intersect_range
 
-    @builtins.property
-    def log_filter(self) -> Optional["scout_compute_resolved_api_LogFilterRangesNode"]:
-        return self._log_filter
-
     @builtins.property
     def min_max_threshold(self) -> Optional["scout_compute_resolved_api_MinMaxThresholdRangesNode"]:
         return self._min_max_threshold
@@ -44412,8 +44461,6 @@ class scout_compute_resolved_api_RangesNode(ConjureUnionType):
             return visitor._extrema(self.extrema)
         if self._type == 'intersectRange' and self.intersect_range is not None:
             return visitor._intersect_range(self.intersect_range)
-        if self._type == 'logFilter' and self.log_filter is not None:
-            return visitor._log_filter(self.log_filter)
         if self._type == 'minMaxThreshold' and self.min_max_threshold is not None:
             return visitor._min_max_threshold(self.min_max_threshold)
         if self._type == 'not' and self.not_ is not None:
@@ -44457,10 +44504,6 @@ class scout_compute_resolved_api_RangesNodeVisitor:
     def _intersect_range(self, intersect_range: "scout_compute_resolved_api_IntersectRangesNode") -> Any:
         pass
 
-    @abstractmethod
-    def _log_filter(self, log_filter: "scout_compute_resolved_api_LogFilterRangesNode") -> Any:
-        pass
-
     @abstractmethod
     def _min_max_threshold(self, min_max_threshold: "scout_compute_resolved_api_MinMaxThresholdRangesNode") -> Any:
         pass
@@ -61443,10 +61486,11 @@ class scout_video_VideoFileService(Service):
         _decoder = ConjureDecoder()
         return _decoder.decode(_response.json(), scout_video_api_VideoFile, self._return_none_for_unknown_union_types)
 
-    def batch_get(self, auth_header: str, request: "scout_video_api_BatchGetVideoFilesRequest") -> "scout_video_api_BatchGetVideoFilesResponse":
+    def batch_get(self, auth_header: str, video_file_rids: List[str] = None) -> List["scout_video_api_VideoFile"]:
         """
         Returns video file metadata associated with the given video file RIDs.
         """
+        video_file_rids = video_file_rids if video_file_rids is not None else []
 
         _headers: Dict[str, Any] = {
             'Accept': 'application/json',
@@ -61460,7 +61504,7 @@ class scout_video_VideoFileService(Service):
         _path_params: Dict[str, Any] = {
         }
 
-        _json: Any = ConjureEncoder().default(request)
+        _json: Any = ConjureEncoder().default(video_file_rids)
 
         _path = '/video-files/v1/video-files/batchGet'
         _path = _path.format(**_path_params)
@@ -61473,7 +61517,7 @@ class scout_video_VideoFileService(Service):
             json=_json)
 
         _decoder = ConjureDecoder()
-        return _decoder.decode(_response.json(), scout_video_api_BatchGetVideoFilesResponse, self._return_none_for_unknown_union_types)
+        return _decoder.decode(_response.json(), List[scout_video_api_VideoFile], self._return_none_for_unknown_union_types)
 
     def search(self, auth_header: str, request: "scout_video_api_SearchVideoFilesRequest") -> "scout_video_api_SearchVideoFilesResponse":
         """
@@ -61603,7 +61647,7 @@ in the UI, but does not permanently delete it. Archived video files can be unarc
 
         return
 
-    def get_ingest_status(self, auth_header: str, video_file_rid: str) -> "scout_video_api_IngestStatusResponse":
+    def get_ingest_status(self, auth_header: str, video_file_rid: str) -> "scout_video_api_GetIngestStatusResponse":
         """
         Get the latest ingest status for a given video file by RID.
         """
@@ -61633,9 +61677,9 @@ in the UI, but does not permanently delete it. Archived video files can be unarc
             json=_json)
 
         _decoder = ConjureDecoder()
-        return _decoder.decode(_response.json(), scout_video_api_IngestStatusResponse, self._return_none_for_unknown_union_types)
+        return _decoder.decode(_response.json(), scout_video_api_GetIngestStatusResponse, self._return_none_for_unknown_union_types)
 
-    def batch_get_ingest_status(self, auth_header: str, video_file_rids: List[str] = None) -> Dict[str, "scout_video_api_IngestStatusResponse"]:
+    def batch_get_ingest_status(self, auth_header: str, video_file_rids: List[str] = None) -> Dict[str, "scout_video_api_VideoFileIngestStatus"]:
         """
         Get the latest ingest status for a set of given video files by RID.
         """
@@ -61666,7 +61710,7 @@ in the UI, but does not permanently delete it. Archived video files can be unarc
             json=_json)
 
         _decoder = ConjureDecoder()
-        return _decoder.decode(_response.json(), Dict[api_rids_VideoFileRid, scout_video_api_IngestStatusResponse], self._return_none_for_unknown_union_types)
+        return _decoder.decode(_response.json(), Dict[api_rids_VideoFileRid, scout_video_api_VideoFileIngestStatus], self._return_none_for_unknown_union_types)
 
     def update_ingest_status(self, auth_header: str, request: "scout_video_api_UpdateIngestStatusRequest", video_file_rid: str) -> None:
         """
@@ -61780,41 +61824,6 @@ class scout_video_VideoSegmentService(Service):
 at the segment-level.
     """
 
-    def get_segment_data(self, auth_header: str, segment_rid: str, video_rid: str) -> Any:
-        """
-        Retrieves the raw bytes of a video segment. The data will be returned as a transport stream.
-        """
-
-        _headers: Dict[str, Any] = {
-            'Accept': 'application/octet-stream',
-            'Authorization': auth_header,
-        }
-
-        _params: Dict[str, Any] = {
-        }
-
-        _path_params: Dict[str, Any] = {
-            'videoRid': video_rid,
-            'segmentRid': segment_rid,
-        }
-
-        _json: Any = None
-
-        _path = '/video/v1/videos/{videoRid}/segments/{segmentRid}'
-        _path = _path.format(**_path_params)
-
-        _response: Response = self._request(
-            'GET',
-            self._uri + _path,
-            params=_params,
-            headers=_headers,
-            stream=True,
-            json=_json)
-
-        _raw = _response.raw
-        _raw.decode_content = True
-        return _raw
-
     def create_segments(self, auth_header: str, request: "scout_video_api_CreateSegmentsRequest", video_rid: str) -> "scout_video_api_CreateSegmentsResponse":
 
         _headers: Dict[str, Any] = {
@@ -62306,58 +62315,6 @@ scout_video_VideoService.__qualname__ = "VideoService"
 scout_video_VideoService.__module__ = "nominal_api.scout_video"
 
 
-class scout_video_api_BatchGetVideoFilesRequest(ConjureBeanType):
-    """
-    Request to get a batch of video files by RIDs
-    """
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'video_file_rids': ConjureFieldDefinition('videoFileRids', List[api_rids_VideoFileRid])
-        }
-
-    __slots__: List[str] = ['_video_file_rids']
-
-    def __init__(self, video_file_rids: List[str]) -> None:
-        self._video_file_rids = video_file_rids
-
-    @builtins.property
-    def video_file_rids(self) -> List[str]:
-        return self._video_file_rids
-
-
-scout_video_api_BatchGetVideoFilesRequest.__name__ = "BatchGetVideoFilesRequest"
-scout_video_api_BatchGetVideoFilesRequest.__qualname__ = "BatchGetVideoFilesRequest"
-scout_video_api_BatchGetVideoFilesRequest.__module__ = "nominal_api.scout_video_api"
-
-
-class scout_video_api_BatchGetVideoFilesResponse(ConjureBeanType):
-    """
-    Paginated response containing requested video file metadata.
-    """
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'video_files': ConjureFieldDefinition('videoFiles', List[scout_video_api_VideoFile])
-        }
-
-    __slots__: List[str] = ['_video_files']
-
-    def __init__(self, video_files: List["scout_video_api_VideoFile"]) -> None:
-        self._video_files = video_files
-
-    @builtins.property
-    def video_files(self) -> List["scout_video_api_VideoFile"]:
-        return self._video_files
-
-
-scout_video_api_BatchGetVideoFilesResponse.__name__ = "BatchGetVideoFilesResponse"
-scout_video_api_BatchGetVideoFilesResponse.__qualname__ = "BatchGetVideoFilesResponse"
-scout_video_api_BatchGetVideoFilesResponse.__module__ = "nominal_api.scout_video_api"
-
-
 class scout_video_api_CreateSegment(ConjureBeanType):
 
     @builtins.classmethod
@@ -62681,6 +62638,29 @@ scout_video_api_ErrorIngestStatus.__qualname__ = "ErrorIngestStatus"
 scout_video_api_ErrorIngestStatus.__module__ = "nominal_api.scout_video_api"
 
 
+class scout_video_api_GetIngestStatusResponse(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'ingest_status': ConjureFieldDefinition('ingestStatus', scout_video_api_VideoFileIngestStatus)
+        }
+
+    __slots__: List[str] = ['_ingest_status']
+
+    def __init__(self, ingest_status: "scout_video_api_VideoFileIngestStatus") -> None:
+        self._ingest_status = ingest_status
+
+    @builtins.property
+    def ingest_status(self) -> "scout_video_api_VideoFileIngestStatus":
+        return self._ingest_status
+
+
+scout_video_api_GetIngestStatusResponse.__name__ = "GetIngestStatusResponse"
+scout_video_api_GetIngestStatusResponse.__qualname__ = "GetIngestStatusResponse"
+scout_video_api_GetIngestStatusResponse.__module__ = "nominal_api.scout_video_api"
+
+
 class scout_video_api_GetSegmentByTimestampRequest(ConjureBeanType):
 
     @builtins.classmethod
@@ -62779,32 +62759,6 @@ scout_video_api_IngestError.__qualname__ = "IngestError"
 scout_video_api_IngestError.__module__ = "nominal_api.scout_video_api"
 
 
-class scout_video_api_IngestStatusResponse(ConjureBeanType):
-    """
-    Response containing the ingest status for a given video file.
-    """
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'ingest_status': ConjureFieldDefinition('ingestStatus', scout_video_api_DetailedIngestStatus)
-        }
-
-    __slots__: List[str] = ['_ingest_status']
-
-    def __init__(self, ingest_status: "scout_video_api_DetailedIngestStatus") -> None:
-        self._ingest_status = ingest_status
-
-    @builtins.property
-    def ingest_status(self) -> "scout_video_api_DetailedIngestStatus":
-        return self._ingest_status
-
-
-scout_video_api_IngestStatusResponse.__name__ = "IngestStatusResponse"
-scout_video_api_IngestStatusResponse.__qualname__ = "IngestStatusResponse"
-scout_video_api_IngestStatusResponse.__module__ = "nominal_api.scout_video_api"
-
-
 class scout_video_api_McapTimestampManifest(ConjureBeanType):
     """
     Timestamps are derived from the mcap file containing the video frames.
@@ -63415,48 +63369,33 @@ class scout_video_api_SegmentTimestamps(ConjureUnionType):
 be frame-mapped. Without a frame-timestamp mapping manifest file, a list of absolute timestamps will be
 automatically assigned to each segment based on media timestamps.. Otherwise, media timestamps will be
 extracted and mapped to those in the provided manifest."""
-    _timestamps: Optional[List["api_Timestamp"]] = None
     _timestamp_mappings: Optional["scout_video_api_TimestampMappings"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'timestamps': ConjureFieldDefinition('timestamps', List[api_Timestamp]),
             'timestamp_mappings': ConjureFieldDefinition('timestampMappings', scout_video_api_TimestampMappings)
         }
 
     def __init__(
             self,
-            timestamps: Optional[List["api_Timestamp"]] = None,
             timestamp_mappings: Optional["scout_video_api_TimestampMappings"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (timestamps is not None) + (timestamp_mappings is not None) != 1:
+            if (timestamp_mappings is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
-            if timestamps is not None:
-                self._timestamps = timestamps
-                self._type = 'timestamps'
             if timestamp_mappings is not None:
                 self._timestamp_mappings = timestamp_mappings
                 self._type = 'timestampMappings'
 
-        elif type_of_union == 'timestamps':
-            if timestamps is None:
-                raise ValueError('a union value must not be None')
-            self._timestamps = timestamps
-            self._type = 'timestamps'
         elif type_of_union == 'timestampMappings':
             if timestamp_mappings is None:
                 raise ValueError('a union value must not be None')
             self._timestamp_mappings = timestamp_mappings
             self._type = 'timestampMappings'
 
-    @builtins.property
-    def timestamps(self) -> Optional[List["api_Timestamp"]]:
-        return self._timestamps
-
     @builtins.property
     def timestamp_mappings(self) -> Optional["scout_video_api_TimestampMappings"]:
         return self._timestamp_mappings
@@ -63464,8 +63403,6 @@ extracted and mapped to those in the provided manifest."""
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, scout_video_api_SegmentTimestampsVisitor):
             raise ValueError('{} is not an instance of scout_video_api_SegmentTimestampsVisitor'.format(visitor.__class__.__name__))
-        if self._type == 'timestamps' and self.timestamps is not None:
-            return visitor._timestamps(self.timestamps)
         if self._type == 'timestampMappings' and self.timestamp_mappings is not None:
             return visitor._timestamp_mappings(self.timestamp_mappings)
 
@@ -63477,10 +63414,6 @@ scout_video_api_SegmentTimestamps.__module__ = "nominal_api.scout_video_api"
 
 class scout_video_api_SegmentTimestampsVisitor:
 
-    @abstractmethod
-    def _timestamps(self, timestamps: List["api_Timestamp"]) -> Any:
-        pass
-
     @abstractmethod
     def _timestamp_mappings(self, timestamp_mappings: "scout_video_api_TimestampMappings") -> Any:
         pass
@@ -63684,24 +63617,21 @@ scout_video_api_UpdateIngestStatusVisitor.__module__ = "nominal_api.scout_video_
 
 
 class scout_video_api_UpdateIngestStatusRequest(ConjureBeanType):
-    """
-    Request to update the ingest status for a video file.
-    """
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'updated_status': ConjureFieldDefinition('updatedStatus', scout_video_api_UpdateIngestStatus)
+            'ingest_status': ConjureFieldDefinition('ingestStatus', scout_video_api_VideoFileIngestStatus)
         }
 
-    __slots__: List[str] = ['_updated_status']
+    __slots__: List[str] = ['_ingest_status']
 
-    def __init__(self, updated_status: "scout_video_api_UpdateIngestStatus") -> None:
-        self._updated_status = updated_status
+    def __init__(self, ingest_status: "scout_video_api_VideoFileIngestStatus") -> None:
+        self._ingest_status = ingest_status
 
     @builtins.property
-    def updated_status(self) -> "scout_video_api_UpdateIngestStatus":
-        return self._updated_status
+    def ingest_status(self) -> "scout_video_api_VideoFileIngestStatus":
+        return self._ingest_status
 
 
 scout_video_api_UpdateIngestStatusRequest.__name__ = "UpdateIngestStatusRequest"
@@ -64136,6 +64066,104 @@ scout_video_api_VideoFile.__qualname__ = "VideoFile"
 scout_video_api_VideoFile.__module__ = "nominal_api.scout_video_api"
 
 
+class scout_video_api_VideoFileIngestStatus(ConjureUnionType):
+    _success: Optional["scout_video_api_SuccessIngestStatus"] = None
+    _error: Optional["scout_video_api_IngestError"] = None
+    _in_progress: Optional["api_Empty"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'success': ConjureFieldDefinition('success', scout_video_api_SuccessIngestStatus),
+            'error': ConjureFieldDefinition('error', scout_video_api_IngestError),
+            'in_progress': ConjureFieldDefinition('inProgress', api_Empty)
+        }
+
+    def __init__(
+            self,
+            success: Optional["scout_video_api_SuccessIngestStatus"] = None,
+            error: Optional["scout_video_api_IngestError"] = None,
+            in_progress: Optional["api_Empty"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (success is not None) + (error is not None) + (in_progress is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if success is not None:
+                self._success = success
+                self._type = 'success'
+            if error is not None:
+                self._error = error
+                self._type = 'error'
+            if in_progress is not None:
+                self._in_progress = in_progress
+                self._type = 'inProgress'
+
+        elif type_of_union == 'success':
+            if success is None:
+                raise ValueError('a union value must not be None')
+            self._success = success
+            self._type = 'success'
+        elif type_of_union == 'error':
+            if error is None:
+                raise ValueError('a union value must not be None')
+            self._error = error
+            self._type = 'error'
+        elif type_of_union == 'inProgress':
+            if in_progress is None:
+                raise ValueError('a union value must not be None')
+            self._in_progress = in_progress
+            self._type = 'inProgress'
+
+    @builtins.property
+    def success(self) -> Optional["scout_video_api_SuccessIngestStatus"]:
+        return self._success
+
+    @builtins.property
+    def error(self) -> Optional["scout_video_api_IngestError"]:
+        return self._error
+
+    @builtins.property
+    def in_progress(self) -> Optional["api_Empty"]:
+        return self._in_progress
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_video_api_VideoFileIngestStatusVisitor):
+            raise ValueError('{} is not an instance of scout_video_api_VideoFileIngestStatusVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'success' and self.success is not None:
+            return visitor._success(self.success)
+        if self._type == 'error' and self.error is not None:
+            return visitor._error(self.error)
+        if self._type == 'inProgress' and self.in_progress is not None:
+            return visitor._in_progress(self.in_progress)
+
+
+scout_video_api_VideoFileIngestStatus.__name__ = "VideoFileIngestStatus"
+scout_video_api_VideoFileIngestStatus.__qualname__ = "VideoFileIngestStatus"
+scout_video_api_VideoFileIngestStatus.__module__ = "nominal_api.scout_video_api"
+
+
+class scout_video_api_VideoFileIngestStatusVisitor:
+
+    @abstractmethod
+    def _success(self, success: "scout_video_api_SuccessIngestStatus") -> Any:
+        pass
+
+    @abstractmethod
+    def _error(self, error: "scout_video_api_IngestError") -> Any:
+        pass
+
+    @abstractmethod
+    def _in_progress(self, in_progress: "api_Empty") -> Any:
+        pass
+
+
+scout_video_api_VideoFileIngestStatusVisitor.__name__ = "VideoFileIngestStatusVisitor"
+scout_video_api_VideoFileIngestStatusVisitor.__qualname__ = "VideoFileIngestStatusVisitor"
+scout_video_api_VideoFileIngestStatusVisitor.__module__ = "nominal_api.scout_video_api"
+
+
 class scout_video_api_VideoFileOriginMetadata(ConjureBeanType):
     """
     Metadata about the origin of the video file. This includes the original source of the video file and 
@@ -64179,6 +64207,9 @@ scout_video_api_VideoFileOriginMetadata.__module__ = "nominal_api.scout_video_ap
 
 
 class scout_video_api_VideoFileSegmentsMetadata(ConjureBeanType):
+    """
+    High-level metadata about the segments comprising a video file post-segmentation.
+    """
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:

nominal_api/scout_compute_api/__init__.py

@@ -134,7 +134,6 @@ from .._impl import (
     scout_compute_api_LogFilterOperator as LogFilterOperator,
     scout_compute_api_LogFilterOperatorVisitor as LogFilterOperatorVisitor,
     scout_compute_api_LogFilterSeries as LogFilterSeries,
-    scout_compute_api_LogPlot as LogPlot,
     scout_compute_api_LogPoint as LogPoint,
     scout_compute_api_LogRegexFilterOperator as LogRegexFilterOperator,
     scout_compute_api_LogSeries as LogSeries,
@@ -182,6 +181,9 @@ from .._impl import (
     scout_compute_api_PageInfo as PageInfo,
     scout_compute_api_PageStrategy as PageStrategy,
     scout_compute_api_PageStrategyVisitor as PageStrategyVisitor,
+    scout_compute_api_PageToken as PageToken,
+    scout_compute_api_PageTokenVisitor as PageTokenVisitor,
+    scout_compute_api_PagedLogPlot as PagedLogPlot,
     scout_compute_api_ParameterInput as ParameterInput,
     scout_compute_api_ParameterizedComputeNodeRequest as ParameterizedComputeNodeRequest,
     scout_compute_api_ParameterizedComputeNodeResponse as ParameterizedComputeNodeResponse,
@@ -247,6 +249,7 @@ from .._impl import (
     scout_compute_api_ThresholdingRanges as ThresholdingRanges,
     scout_compute_api_TimeBucketedGeoPlot as TimeBucketedGeoPlot,
     scout_compute_api_TimeDifferenceSeries as TimeDifferenceSeries,
+    scout_compute_api_TimestampAndId as TimestampAndId,
     scout_compute_api_TimestampConstant as TimestampConstant,
     scout_compute_api_TimestampConstantVisitor as TimestampConstantVisitor,
     scout_compute_api_UnaryArithmeticOperation as UnaryArithmeticOperation,

nominal_api/scout_compute_resolved_api/__init__.py

@@ -44,8 +44,7 @@ from .._impl import (
     scout_compute_resolved_api_IntersectRangesNode as IntersectRangesNode,
     scout_compute_resolved_api_LatLongBounds as LatLongBounds,
     scout_compute_resolved_api_LatLongGeoNode as LatLongGeoNode,
-    scout_compute_resolved_api_LogFilterRangesNode as LogFilterRangesNode,
-    scout_compute_resolved_api_LogFilterTransformationSeriesNode as LogFilterTransformationSeriesNode,
+    scout_compute_resolved_api_LogFilterSeriesNode as LogFilterSeriesNode,
     scout_compute_resolved_api_LogSeriesNode as LogSeriesNode,
     scout_compute_resolved_api_LogSeriesNodeVisitor as LogSeriesNodeVisitor,
     scout_compute_resolved_api_LogTimeShiftSeriesNode as LogTimeShiftSeriesNode,

nominal_api/scout_video_api/__init__.py

@@ -1,7 +1,5 @@
 # coding=utf-8
 from .._impl import (
-    scout_video_api_BatchGetVideoFilesRequest as BatchGetVideoFilesRequest,
-    scout_video_api_BatchGetVideoFilesResponse as BatchGetVideoFilesResponse,
     scout_video_api_CreateSegment as CreateSegment,
     scout_video_api_CreateSegmentsRequest as CreateSegmentsRequest,
     scout_video_api_CreateSegmentsResponse as CreateSegmentsResponse,
@@ -11,11 +9,11 @@ from .._impl import (
     scout_video_api_DetailedIngestStatusVisitor as DetailedIngestStatusVisitor,
     scout_video_api_ErrorIngestStatus as ErrorIngestStatus,
     scout_video_api_ErrorType as ErrorType,
+    scout_video_api_GetIngestStatusResponse as GetIngestStatusResponse,
     scout_video_api_GetSegmentByTimestampRequest as GetSegmentByTimestampRequest,
     scout_video_api_GetVideosRequest as GetVideosRequest,
     scout_video_api_GetVideosResponse as GetVideosResponse,
     scout_video_api_IngestError as IngestError,
-    scout_video_api_IngestStatusResponse as IngestStatusResponse,
     scout_video_api_McapTimestampManifest as McapTimestampManifest,
     scout_video_api_NoTimestampManifest as NoTimestampManifest,
     scout_video_api_ScaleParameter as ScaleParameter,
@@ -44,6 +42,8 @@ from .._impl import (
     scout_video_api_Video as Video,
     scout_video_api_VideoAllSegmentsMetadata as VideoAllSegmentsMetadata,
     scout_video_api_VideoFile as VideoFile,
+    scout_video_api_VideoFileIngestStatus as VideoFileIngestStatus,
+    scout_video_api_VideoFileIngestStatusVisitor as VideoFileIngestStatusVisitor,
     scout_video_api_VideoFileOriginMetadata as VideoFileOriginMetadata,
     scout_video_api_VideoFileSegmentsMetadata as VideoFileSegmentsMetadata,
     scout_video_api_VideoFileTimestampManifest as VideoFileTimestampManifest,

{nominal_api-0.561.2.dist-info → nominal_api-0.563.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: nominal-api
-Version: 0.561.2
+Version: 0.563.0
 Requires-Python: >=3.8
 Requires-Dist: requests
 Requires-Dist: conjure-python-client<3,>=2.8.0

{nominal_api-0.561.2.dist-info → nominal_api-0.563.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
-nominal_api/__init__.py,sha256=Y_tEygjSEE0VgG_idNX7ApHj_lrYY39Y_oYtwQyFpOs,1791
-nominal_api/_impl.py,sha256=QI-fkoSmKNOZd1_tCnnbk9jirTONC6EihQQmnmbVEdI,2750650
+nominal_api/__init__.py,sha256=M7b1Q3JDpVaIH1PrVLwb5Nfij4pjdjUVyQk6vRbk5oY,1791
+nominal_api/_impl.py,sha256=wX4r8S-aD_NkPwKDXcnBjsr9H6BSkgdjldt5pJ-JRlc,2751758
 nominal_api/py.typed,sha256=eoZ6GfifbqhMLNzjlqRDVil-yyBkOmVN9ujSgJWNBlY,15
 nominal_api/api/__init__.py,sha256=kJBEE_HLVpKYdLH12KyO-cSAVzwxYpBwaaDutCtT-LM,1236
 nominal_api/api_rids/__init__.py,sha256=MwCU7tf4EQBdNPY12rgPdr4y11iowEXxYqtNCvw7sdo,380
@@ -27,10 +27,10 @@ nominal_api/scout_checklistexecution_api/__init__.py,sha256=PfMFzie0xO5d5WSpB3bE
 nominal_api/scout_checks_api/__init__.py,sha256=RJH7HsXjUhItC11V9C-hfv6lkIfiSXyxnB8slUpaT2g,5203
 nominal_api/scout_comparisonnotebook_api/__init__.py,sha256=8BL5jE9NDxqCj9DyvZWSPhq6zw2J7xp6aLsl3x9rpyw,4530
 nominal_api/scout_comparisonrun_api/__init__.py,sha256=1LCXQe64tDqqeMQixW8PI-R_edSz7F5X0x2_ufEuC8M,480
-nominal_api/scout_compute_api/__init__.py,sha256=JUkoyU-2JCFPa5aBl45rfNvo5DuxuPkWfJiN7TbEyZ4,17044
+nominal_api/scout_compute_api/__init__.py,sha256=DGXb6TQbX4DklA6W6rTqPqkU2W5KdmsO1xZBD2MdFXA,17216
 nominal_api/scout_compute_api_deprecated/__init__.py,sha256=RggSfc6C1VR1-kNXPWybpfw3hZbkQ1gvxEisFZCHdnM,3732
 nominal_api/scout_compute_representation_api/__init__.py,sha256=FezODo7sI8m6tDhPPK_gZX1qXImi4O3TUprDoNUuWpk,1672
-nominal_api/scout_compute_resolved_api/__init__.py,sha256=7o7MZHyvcHyXlonWkLWpMeO13XPa9F8CD02NP3_5rQo,8801
+nominal_api/scout_compute_resolved_api/__init__.py,sha256=-IZ6eqgHGJsK3Z2URCYUlUgoyghlSMT2Ml7xJjmJePs,8698
 nominal_api/scout_dataexport_api/__init__.py,sha256=pWRQdQJOObD0jITRYLw3AxeDJSrJQqAdFZACxULqA4o,1487
 nominal_api/scout_datareview_api/__init__.py,sha256=ETAl7VWaxOk8g9uwfsKo573-3qfDNbGQ1_QBQaDPRxk,8405
 nominal_api/scout_datasource/__init__.py,sha256=1NWMrEx-JOEb4Pmd2oAqcpSmQB3g3lxgxFenWEtcF2M,101
@@ -52,7 +52,7 @@ nominal_api/scout_template_api/__init__.py,sha256=bsu8qPiZ4gf67G5iFvwsfkqEKJRZ7L
 nominal_api/scout_units_api/__init__.py,sha256=KxRDScfumX__0ncWJftGvgApn_LBTfnIBAvnaBrcA5A,368
 nominal_api/scout_versioning_api/__init__.py,sha256=Sf4T4t0rZXNRIZgkqLBN3yh0sAnrxiuzaTfDQVVkyO4,1323
 nominal_api/scout_video/__init__.py,sha256=zB7mM23yGAgC529rF4gjDmqcLRbsp0kJA3xef8meZko,200
-nominal_api/scout_video_api/__init__.py,sha256=u8QBMJLP13HeCieE716zPq_2Yia3b0Uf80teGjEZ7nE,3402
+nominal_api/scout_video_api/__init__.py,sha256=VRcjlc11avwaCLaWHWlqcfDaNmYV0ScyfAsh8Oec47w,3404
 nominal_api/scout_workbookcommon_api/__init__.py,sha256=6Ai0cYNOOw2A6JOlKzraTbpZwolspM-WTqVGLMN2HdI,413
 nominal_api/secrets_api/__init__.py,sha256=V5BpnbNzjdMP8kgvR2N6SEVcVyXi6Vyl_lh_5fKjJzw,736
 nominal_api/storage_datasource_api/__init__.py,sha256=jh_OZE_b4nBNAvnyenBjw8aGZOnvIXR6qvUKd31fXOk,445
@@ -66,7 +66,7 @@ nominal_api/timeseries_logicalseries_api/__init__.py,sha256=KuHLafDLeHzOTl0B6j7T
 nominal_api/timeseries_seriescache/__init__.py,sha256=tFCkNuyrVMgtj-HIl1pOYPJHaL2VikI4C_x97bX_Lcs,109
 nominal_api/timeseries_seriescache_api/__init__.py,sha256=U9EhlqdF9qzD1O9al0vcvcdgS_C5lq-lN3Kmr0K3g84,1191
 nominal_api/upload_api/__init__.py,sha256=ZMudWMSqCrNozohbHaJKuxJnT9Edepe7nxxXMz_pT9k,87
-nominal_api-0.561.2.dist-info/METADATA,sha256=Tk41Wi7hnfmmIRqaTbli6yOgtq07QBe1nS-zh11dNwU,199
-nominal_api-0.561.2.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-nominal_api-0.561.2.dist-info/top_level.txt,sha256=gI1ZdNJbuHcJZeKtCzzBXsEtpU1GX6XJKs6ksi_gCRA,12
-nominal_api-0.561.2.dist-info/RECORD,,
+nominal_api-0.563.0.dist-info/METADATA,sha256=e9GqnDv4uZ3oyU-hRlHOjGK4swnFli4J0lwxUyarX_Q,199
+nominal_api-0.563.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+nominal_api-0.563.0.dist-info/top_level.txt,sha256=gI1ZdNJbuHcJZeKtCzzBXsEtpU1GX6XJKs6ksi_gCRA,12
+nominal_api-0.563.0.dist-info/RECORD,,