nominal-api 0.655.0__py3-none-any.whl → 0.663.2__py3-none-any.whl

nominal_api/_impl.py

@@ -8805,20 +8805,25 @@ class ingest_api_IngestMetadata(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'timestamp_metadata': ConjureFieldDefinition('timestampMetadata', OptionalTypeWrapper[ingest_api_TimestampMetadata]),
-            'channel_prefix': ConjureFieldDefinition('channelPrefix', OptionalTypeWrapper[str])
+            'channel_prefix': ConjureFieldDefinition('channelPrefix', OptionalTypeWrapper[str]),
+            'tag_columns': ConjureFieldDefinition('tagColumns', OptionalTypeWrapper[Dict[api_TagName, api_ColumnName]]),
+            'additional_file_tags': ConjureFieldDefinition('additionalFileTags', OptionalTypeWrapper[Dict[api_TagName, api_TagValue]])
         }
 
-    __slots__: List[str] = ['_timestamp_metadata', '_channel_prefix']
+    __slots__: List[str] = ['_timestamp_metadata', '_channel_prefix', '_tag_columns', '_additional_file_tags']
 
-    def __init__(self, channel_prefix: Optional[str] = None, timestamp_metadata: Optional["ingest_api_TimestampMetadata"] = None) -> None:
+    def __init__(self, additional_file_tags: Optional[Dict[str, str]] = None, channel_prefix: Optional[str] = None, tag_columns: Optional[Dict[str, str]] = None, timestamp_metadata: Optional["ingest_api_TimestampMetadata"] = None) -> None:
         self._timestamp_metadata = timestamp_metadata
         self._channel_prefix = channel_prefix
+        self._tag_columns = tag_columns
+        self._additional_file_tags = additional_file_tags
 
     @builtins.property
     def timestamp_metadata(self) -> Optional["ingest_api_TimestampMetadata"]:
         """
-        The timestamp metadata will be recovered from the DatasetFiles table if possible.
-If not found, this field must be populated to successfully reingest.
+        The timestamp metadata will be recovered from the dataset files if possible.
+Older datasets may have unrecoverable timestamp metadata.
+If unrecoverable, reingestion will throw MissingMetadataForReingest if not provided in request.
         """
         return self._timestamp_metadata
 
@@ -8826,10 +8831,26 @@ If not found, this field must be populated to successfully reingest.
     def channel_prefix(self) -> Optional[str]:
         """
         Channel prefix to use when reingesting the dataset.
-Defaults to empty string.
+Defaults to empty string. Not recoverable from prior ingests and must be provided in request if needed.
         """
         return self._channel_prefix
 
+    @builtins.property
+    def tag_columns(self) -> Optional[Dict[str, str]]:
+        """
+        A map of tag names to column names to derive the tag values from.
+Not recoverable from prior ingests and must be provided in request if needed.
+        """
+        return self._tag_columns
+
+    @builtins.property
+    def additional_file_tags(self) -> Optional[Dict[str, str]]:
+        """
+        Additional tags to apply to all dataset files within the the given dataset.
+Not recoverable from prior ingests and must be provided in request if needed.
+        """
+        return self._additional_file_tags
+
 
 ingest_api_IngestMetadata.__name__ = "IngestMetadata"
 ingest_api_IngestMetadata.__qualname__ = "IngestMetadata"
@@ -9490,7 +9511,7 @@ existing one.
         """
         Re-ingests data from provided source datasets into either an existing target dataset, or a new one.
 Only supported for CSV and Parquet dataset files.
-Cannot ingest from streaming (V2) datasets due to data loss for tags and streaming data.
+Will only reingest dataset files and will drop streaming data from datasets.
         """
 
         _headers: Dict[str, Any] = {
@@ -9507,7 +9528,7 @@ Cannot ingest from streaming (V2) datasets due to data loss for tags and streami
 
         _json: Any = ConjureEncoder().default(request)
 
-        _path = '/ingest/v1/reingest-dataset'
+        _path = '/ingest/v1/reingest-dataset-files'
         _path = _path.format(**_path_params)
 
         _response: Response = self._request(
@@ -10965,8 +10986,8 @@ Will attempt to reingest from datasets in list order.
     def ingest_metadata(self) -> Dict[str, "ingest_api_IngestMetadata"]:
         """
         Mapping of dataset to ingest metadata.
-Ingest metadata will be recovered from existing files if possible.
-If unrecoverable, will fall back to ingest metadata provided in this field.
+Ingest metadata only needs to be provided in request if it cannot be recovered from prior ingests.
+See documentation on each field to determine what metadata can be auto-recovered.
         """
         return self._ingest_metadata
 
@@ -12439,6 +12460,72 @@ ingest_workflow_api_ExtractorJobState.__qualname__ = "ExtractorJobState"
 ingest_workflow_api_ExtractorJobState.__module__ = "nominal_api.ingest_workflow_api"
 
 
+class ingest_workflow_api_FetchExtractorJobLogsRequest(ConjureBeanType):
+    """
+    Request to fetch logs for all containers in a completed extractor job's pod.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'workspace_rid': ConjureFieldDefinition('workspaceRid', api_rids_WorkspaceRid),
+            'log_dataset_rid': ConjureFieldDefinition('logDatasetRid', api_rids_DatasetRid),
+            'ingest_job_uuid': ConjureFieldDefinition('ingestJobUuid', str),
+            'bearer_token': ConjureFieldDefinition('bearerToken', str),
+            'extractor_rid': ConjureFieldDefinition('extractorRid', ingest_api_ContainerizedExtractorRid)
+        }
+
+    __slots__: List[str] = ['_workspace_rid', '_log_dataset_rid', '_ingest_job_uuid', '_bearer_token', '_extractor_rid']
+
+    def __init__(self, bearer_token: str, extractor_rid: str, ingest_job_uuid: str, log_dataset_rid: str, workspace_rid: str) -> None:
+        self._workspace_rid = workspace_rid
+        self._log_dataset_rid = log_dataset_rid
+        self._ingest_job_uuid = ingest_job_uuid
+        self._bearer_token = bearer_token
+        self._extractor_rid = extractor_rid
+
+    @builtins.property
+    def workspace_rid(self) -> str:
+        return self._workspace_rid
+
+    @builtins.property
+    def log_dataset_rid(self) -> str:
+        return self._log_dataset_rid
+
+    @builtins.property
+    def ingest_job_uuid(self) -> str:
+        return self._ingest_job_uuid
+
+    @builtins.property
+    def bearer_token(self) -> str:
+        return self._bearer_token
+
+    @builtins.property
+    def extractor_rid(self) -> str:
+        return self._extractor_rid
+
+
+ingest_workflow_api_FetchExtractorJobLogsRequest.__name__ = "FetchExtractorJobLogsRequest"
+ingest_workflow_api_FetchExtractorJobLogsRequest.__qualname__ = "FetchExtractorJobLogsRequest"
+ingest_workflow_api_FetchExtractorJobLogsRequest.__module__ = "nominal_api.ingest_workflow_api"
+
+
+class ingest_workflow_api_FetchExtractorJobLogsResponse(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+        }
+
+    __slots__: List[str] = []
+
+
+
+ingest_workflow_api_FetchExtractorJobLogsResponse.__name__ = "FetchExtractorJobLogsResponse"
+ingest_workflow_api_FetchExtractorJobLogsResponse.__qualname__ = "FetchExtractorJobLogsResponse"
+ingest_workflow_api_FetchExtractorJobLogsResponse.__module__ = "nominal_api.ingest_workflow_api"
+
+
 class ingest_workflow_api_GetExtractorJobStateRequest(ConjureBeanType):
 
     @builtins.classmethod
@@ -13394,12 +13481,20 @@ class persistent_compute_api_InvalidComputationType(ConjureEnumType):
     '''INTEGRAL'''
     STALENESS_DETECTION = 'STALENESS_DETECTION'
     '''STALENESS_DETECTION'''
+    TIME_RANGE_FILTER = 'TIME_RANGE_FILTER'
+    '''TIME_RANGE_FILTER'''
     FREQUENCY_DOMAIN = 'FREQUENCY_DOMAIN'
     '''FREQUENCY_DOMAIN'''
     CURVE_FITTING = 'CURVE_FITTING'
     '''CURVE_FITTING'''
     PAGE_SUMMARIZATION_STRATEGY = 'PAGE_SUMMARIZATION_STRATEGY'
     '''PAGE_SUMMARIZATION_STRATEGY'''
+    LOOK_BACK_TOO_FAR = 'LOOK_BACK_TOO_FAR'
+    '''LOOK_BACK_TOO_FAR'''
+    LOG_SERIES = 'LOG_SERIES'
+    '''LOG_SERIES'''
+    LITERAL_RANGES = 'LITERAL_RANGES'
+    '''LITERAL_RANGES'''
     UNKNOWN = 'UNKNOWN'
     '''UNKNOWN'''
 
@@ -18222,7 +18317,7 @@ Throws if the asset already has data scopes with data scope names matching those
 
         return
 
-    def unarchive(self, auth_header: str, rid: str) -> None:
+    def unarchive(self, auth_header: str, rid: str, include_linked_workbooks: Optional[bool] = None) -> None:
 
         _headers: Dict[str, Any] = {
             'Accept': 'application/json',
@@ -18230,6 +18325,7 @@ Throws if the asset already has data scopes with data scope names matching those
         }
 
         _params: Dict[str, Any] = {
+            'includeLinkedWorkbooks': include_linked_workbooks,
         }
 
         _path_params: Dict[str, Any] = {
@@ -22256,6 +22352,89 @@ scout_chartdefinition_api_ChecklistChartDefinitionV1.__qualname__ = "ChecklistCh
 scout_chartdefinition_api_ChecklistChartDefinitionV1.__module__ = "nominal_api.scout_chartdefinition_api"
 
 
+class scout_chartdefinition_api_ColorStyle(ConjureUnionType):
+    _mapped: Optional[Dict[str, str]] = None
+    _single: Optional[str] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'mapped': ConjureFieldDefinition('mapped', Dict[str, scout_api_HexColor]),
+            'single': ConjureFieldDefinition('single', scout_api_HexColor)
+        }
+
+    def __init__(
+            self,
+            mapped: Optional[Dict[str, str]] = None,
+            single: Optional[str] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (mapped is not None) + (single is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if mapped is not None:
+                self._mapped = mapped
+                self._type = 'mapped'
+            if single is not None:
+                self._single = single
+                self._type = 'single'
+
+        elif type_of_union == 'mapped':
+            if mapped is None:
+                raise ValueError('a union value must not be None')
+            self._mapped = mapped
+            self._type = 'mapped'
+        elif type_of_union == 'single':
+            if single is None:
+                raise ValueError('a union value must not be None')
+            self._single = single
+            self._type = 'single'
+
+    @builtins.property
+    def mapped(self) -> Optional[Dict[str, str]]:
+        """
+        Defines specific colors for specific values
+        """
+        return self._mapped
+
+    @builtins.property
+    def single(self) -> Optional[str]:
+        """
+        A single color to apply to the whole plot
+        """
+        return self._single
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_chartdefinition_api_ColorStyleVisitor):
+            raise ValueError('{} is not an instance of scout_chartdefinition_api_ColorStyleVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'mapped' and self.mapped is not None:
+            return visitor._mapped(self.mapped)
+        if self._type == 'single' and self.single is not None:
+            return visitor._single(self.single)
+
+
+scout_chartdefinition_api_ColorStyle.__name__ = "ColorStyle"
+scout_chartdefinition_api_ColorStyle.__qualname__ = "ColorStyle"
+scout_chartdefinition_api_ColorStyle.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
+class scout_chartdefinition_api_ColorStyleVisitor:
+
+    @abstractmethod
+    def _mapped(self, mapped: Dict[str, str]) -> Any:
+        pass
+
+    @abstractmethod
+    def _single(self, single: str) -> Any:
+        pass
+
+
+scout_chartdefinition_api_ColorStyleVisitor.__name__ = "ColorStyleVisitor"
+scout_chartdefinition_api_ColorStyleVisitor.__qualname__ = "ColorStyleVisitor"
+scout_chartdefinition_api_ColorStyleVisitor.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
 class scout_chartdefinition_api_DefaultFill(ConjureBeanType):
 
     @builtins.classmethod
@@ -24011,6 +24190,140 @@ scout_chartdefinition_api_NumericValueVisualisationV2Visitor.__qualname__ = "Num
 scout_chartdefinition_api_NumericValueVisualisationV2Visitor.__module__ = "nominal_api.scout_chartdefinition_api"
 
 
+class scout_chartdefinition_api_OverlayScope(ConjureEnumType):
+
+    ROW = 'ROW'
+    '''ROW'''
+    PANEL = 'PANEL'
+    '''PANEL'''
+    UNKNOWN = 'UNKNOWN'
+    '''UNKNOWN'''
+
+    def __reduce_ex__(self, proto):
+        return self.__class__, (self.name,)
+
+
+scout_chartdefinition_api_OverlayScope.__name__ = "OverlayScope"
+scout_chartdefinition_api_OverlayScope.__qualname__ = "OverlayScope"
+scout_chartdefinition_api_OverlayScope.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
+class scout_chartdefinition_api_PersistAll(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+        }
+
+    __slots__: List[str] = []
+
+
+
+scout_chartdefinition_api_PersistAll.__name__ = "PersistAll"
+scout_chartdefinition_api_PersistAll.__qualname__ = "PersistAll"
+scout_chartdefinition_api_PersistAll.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
+class scout_chartdefinition_api_PersistByValue(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'values': ConjureFieldDefinition('values', List[str])
+        }
+
+    __slots__: List[str] = ['_values']
+
+    def __init__(self, values: List[str]) -> None:
+        self._values = values
+
+    @builtins.property
+    def values(self) -> List[str]:
+        return self._values
+
+
+scout_chartdefinition_api_PersistByValue.__name__ = "PersistByValue"
+scout_chartdefinition_api_PersistByValue.__qualname__ = "PersistByValue"
+scout_chartdefinition_api_PersistByValue.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
+class scout_chartdefinition_api_PersistValueOverlay(ConjureUnionType):
+    _by_value: Optional["scout_chartdefinition_api_PersistByValue"] = None
+    _all: Optional["scout_chartdefinition_api_PersistAll"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'by_value': ConjureFieldDefinition('byValue', scout_chartdefinition_api_PersistByValue),
+            'all': ConjureFieldDefinition('all', scout_chartdefinition_api_PersistAll)
+        }
+
+    def __init__(
+            self,
+            by_value: Optional["scout_chartdefinition_api_PersistByValue"] = None,
+            all: Optional["scout_chartdefinition_api_PersistAll"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (by_value is not None) + (all is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if by_value is not None:
+                self._by_value = by_value
+                self._type = 'byValue'
+            if all is not None:
+                self._all = all
+                self._type = 'all'
+
+        elif type_of_union == 'byValue':
+            if by_value is None:
+                raise ValueError('a union value must not be None')
+            self._by_value = by_value
+            self._type = 'byValue'
+        elif type_of_union == 'all':
+            if all is None:
+                raise ValueError('a union value must not be None')
+            self._all = all
+            self._type = 'all'
+
+    @builtins.property
+    def by_value(self) -> Optional["scout_chartdefinition_api_PersistByValue"]:
+        return self._by_value
+
+    @builtins.property
+    def all(self) -> Optional["scout_chartdefinition_api_PersistAll"]:
+        return self._all
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_chartdefinition_api_PersistValueOverlayVisitor):
+            raise ValueError('{} is not an instance of scout_chartdefinition_api_PersistValueOverlayVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'byValue' and self.by_value is not None:
+            return visitor._by_value(self.by_value)
+        if self._type == 'all' and self.all is not None:
+            return visitor._all(self.all)
+
+
+scout_chartdefinition_api_PersistValueOverlay.__name__ = "PersistValueOverlay"
+scout_chartdefinition_api_PersistValueOverlay.__qualname__ = "PersistValueOverlay"
+scout_chartdefinition_api_PersistValueOverlay.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
+class scout_chartdefinition_api_PersistValueOverlayVisitor:
+
+    @abstractmethod
+    def _by_value(self, by_value: "scout_chartdefinition_api_PersistByValue") -> Any:
+        pass
+
+    @abstractmethod
+    def _all(self, all: "scout_chartdefinition_api_PersistAll") -> Any:
+        pass
+
+
+scout_chartdefinition_api_PersistValueOverlayVisitor.__name__ = "PersistValueOverlayVisitor"
+scout_chartdefinition_api_PersistValueOverlayVisitor.__qualname__ = "PersistValueOverlayVisitor"
+scout_chartdefinition_api_PersistValueOverlayVisitor.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
 class scout_chartdefinition_api_PlotlyPanelDefinition(ConjureUnionType):
     _v1: Optional["scout_chartdefinition_api_PlotlyPanelDefinitionV1"] = None
 
@@ -24124,6 +24437,24 @@ scout_chartdefinition_api_PlotlyPreset.__qualname__ = "PlotlyPreset"
 scout_chartdefinition_api_PlotlyPreset.__module__ = "nominal_api.scout_chartdefinition_api"
 
 
+class scout_chartdefinition_api_Position(ConjureEnumType):
+
+    TOP = 'TOP'
+    '''TOP'''
+    BOTTOM = 'BOTTOM'
+    '''BOTTOM'''
+    UNKNOWN = 'UNKNOWN'
+    '''UNKNOWN'''
+
+    def __reduce_ex__(self, proto):
+        return self.__class__, (self.name,)
+
+
+scout_chartdefinition_api_Position.__name__ = "Position"
+scout_chartdefinition_api_Position.__qualname__ = "Position"
+scout_chartdefinition_api_Position.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
 class scout_chartdefinition_api_RangeCellConfig(ConjureBeanType):
 
     @builtins.classmethod
@@ -24523,6 +24854,99 @@ scout_chartdefinition_api_TimeSeriesChartDefinitionV1.__qualname__ = "TimeSeries
 scout_chartdefinition_api_TimeSeriesChartDefinitionV1.__module__ = "nominal_api.scout_chartdefinition_api"
 
 
+class scout_chartdefinition_api_TimeSeriesEnumPlot(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'color': ConjureFieldDefinition('color', scout_chartdefinition_api_ColorStyle),
+            'position': ConjureFieldDefinition('position', scout_chartdefinition_api_Position),
+            'persist_value_overlays': ConjureFieldDefinition('persistValueOverlays', scout_chartdefinition_api_PersistValueOverlay),
+            'overlay_scope': ConjureFieldDefinition('overlayScope', scout_chartdefinition_api_OverlayScope),
+            'display_inline': ConjureFieldDefinition('displayInline', bool)
+        }
+
+    __slots__: List[str] = ['_color', '_position', '_persist_value_overlays', '_overlay_scope', '_display_inline']
+
+    def __init__(self, color: "scout_chartdefinition_api_ColorStyle", display_inline: bool, overlay_scope: "scout_chartdefinition_api_OverlayScope", persist_value_overlays: "scout_chartdefinition_api_PersistValueOverlay", position: "scout_chartdefinition_api_Position") -> None:
+        self._color = color
+        self._position = position
+        self._persist_value_overlays = persist_value_overlays
+        self._overlay_scope = overlay_scope
+        self._display_inline = display_inline
+
+    @builtins.property
+    def color(self) -> "scout_chartdefinition_api_ColorStyle":
+        """
+        How to color the value ranges
+        """
+        return self._color
+
+    @builtins.property
+    def position(self) -> "scout_chartdefinition_api_Position":
+        """
+        Where to place the plot within the row
+        """
+        return self._position
+
+    @builtins.property
+    def persist_value_overlays(self) -> "scout_chartdefinition_api_PersistValueOverlay":
+        """
+        Render certain values' full-row/full-panel color overlays
+even when not interacting with the plot
+        """
+        return self._persist_value_overlays
+
+    @builtins.property
+    def overlay_scope(self) -> "scout_chartdefinition_api_OverlayScope":
+        """
+        How far to extend the overlay
+        """
+        return self._overlay_scope
+
+    @builtins.property
+    def display_inline(self) -> bool:
+        """
+        Whether to display the value ranges on the same line or stagger them
+such that each value gets a line to itself
+        """
+        return self._display_inline
+
+
+scout_chartdefinition_api_TimeSeriesEnumPlot.__name__ = "TimeSeriesEnumPlot"
+scout_chartdefinition_api_TimeSeriesEnumPlot.__qualname__ = "TimeSeriesEnumPlot"
+scout_chartdefinition_api_TimeSeriesEnumPlot.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
+class scout_chartdefinition_api_TimeSeriesNumericPlot(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'color': ConjureFieldDefinition('color', scout_api_HexColor),
+            'line_style': ConjureFieldDefinition('lineStyle', scout_chartdefinition_api_LineStyle)
+        }
+
+    __slots__: List[str] = ['_color', '_line_style']
+
+    def __init__(self, color: str, line_style: "scout_chartdefinition_api_LineStyle") -> None:
+        self._color = color
+        self._line_style = line_style
+
+    @builtins.property
+    def color(self) -> str:
+        return self._color
+
+    @builtins.property
+    def line_style(self) -> "scout_chartdefinition_api_LineStyle":
+        return self._line_style
+
+
+scout_chartdefinition_api_TimeSeriesNumericPlot.__name__ = "TimeSeriesNumericPlot"
+scout_chartdefinition_api_TimeSeriesNumericPlot.__qualname__ = "TimeSeriesNumericPlot"
+scout_chartdefinition_api_TimeSeriesNumericPlot.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
 class scout_chartdefinition_api_TimeSeriesPlot(ConjureBeanType):
 
     @builtins.classmethod
@@ -24570,6 +24994,168 @@ scout_chartdefinition_api_TimeSeriesPlot.__qualname__ = "TimeSeriesPlot"
 scout_chartdefinition_api_TimeSeriesPlot.__module__ = "nominal_api.scout_chartdefinition_api"
 
 
+class scout_chartdefinition_api_TimeSeriesPlotConfig(ConjureUnionType):
+    _numeric: Optional["scout_chartdefinition_api_TimeSeriesNumericPlot"] = None
+    _range: Optional["scout_chartdefinition_api_TimeSeriesRangePlot"] = None
+    _enum: Optional["scout_chartdefinition_api_TimeSeriesEnumPlot"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'numeric': ConjureFieldDefinition('numeric', scout_chartdefinition_api_TimeSeriesNumericPlot),
+            'range': ConjureFieldDefinition('range', scout_chartdefinition_api_TimeSeriesRangePlot),
+            'enum': ConjureFieldDefinition('enum', scout_chartdefinition_api_TimeSeriesEnumPlot)
+        }
+
+    def __init__(
+            self,
+            numeric: Optional["scout_chartdefinition_api_TimeSeriesNumericPlot"] = None,
+            range: Optional["scout_chartdefinition_api_TimeSeriesRangePlot"] = None,
+            enum: Optional["scout_chartdefinition_api_TimeSeriesEnumPlot"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (numeric is not None) + (range is not None) + (enum is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if numeric is not None:
+                self._numeric = numeric
+                self._type = 'numeric'
+            if range is not None:
+                self._range = range
+                self._type = 'range'
+            if enum is not None:
+                self._enum = enum
+                self._type = 'enum'
+
+        elif type_of_union == 'numeric':
+            if numeric is None:
+                raise ValueError('a union value must not be None')
+            self._numeric = numeric
+            self._type = 'numeric'
+        elif type_of_union == 'range':
+            if range is None:
+                raise ValueError('a union value must not be None')
+            self._range = range
+            self._type = 'range'
+        elif type_of_union == 'enum':
+            if enum is None:
+                raise ValueError('a union value must not be None')
+            self._enum = enum
+            self._type = 'enum'
+
+    @builtins.property
+    def numeric(self) -> Optional["scout_chartdefinition_api_TimeSeriesNumericPlot"]:
+        return self._numeric
+
+    @builtins.property
+    def range(self) -> Optional["scout_chartdefinition_api_TimeSeriesRangePlot"]:
+        return self._range
+
+    @builtins.property
+    def enum(self) -> Optional["scout_chartdefinition_api_TimeSeriesEnumPlot"]:
+        return self._enum
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_chartdefinition_api_TimeSeriesPlotConfigVisitor):
+            raise ValueError('{} is not an instance of scout_chartdefinition_api_TimeSeriesPlotConfigVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'numeric' and self.numeric is not None:
+            return visitor._numeric(self.numeric)
+        if self._type == 'range' and self.range is not None:
+            return visitor._range(self.range)
+        if self._type == 'enum' and self.enum is not None:
+            return visitor._enum(self.enum)
+
+
+scout_chartdefinition_api_TimeSeriesPlotConfig.__name__ = "TimeSeriesPlotConfig"
+scout_chartdefinition_api_TimeSeriesPlotConfig.__qualname__ = "TimeSeriesPlotConfig"
+scout_chartdefinition_api_TimeSeriesPlotConfig.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
+class scout_chartdefinition_api_TimeSeriesPlotConfigVisitor:
+
+    @abstractmethod
+    def _numeric(self, numeric: "scout_chartdefinition_api_TimeSeriesNumericPlot") -> Any:
+        pass
+
+    @abstractmethod
+    def _range(self, range: "scout_chartdefinition_api_TimeSeriesRangePlot") -> Any:
+        pass
+
+    @abstractmethod
+    def _enum(self, enum: "scout_chartdefinition_api_TimeSeriesEnumPlot") -> Any:
+        pass
+
+
+scout_chartdefinition_api_TimeSeriesPlotConfigVisitor.__name__ = "TimeSeriesPlotConfigVisitor"
+scout_chartdefinition_api_TimeSeriesPlotConfigVisitor.__qualname__ = "TimeSeriesPlotConfigVisitor"
+scout_chartdefinition_api_TimeSeriesPlotConfigVisitor.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
+class scout_chartdefinition_api_TimeSeriesPlotV2(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'variable_name': ConjureFieldDefinition('variableName', scout_channelvariables_api_ChannelVariableName),
+            'enabled': ConjureFieldDefinition('enabled', OptionalTypeWrapper[bool]),
+            'y_axis_id': ConjureFieldDefinition('yAxisId', scout_chartdefinition_api_AxisId),
+            'type': ConjureFieldDefinition('type', scout_chartdefinition_api_TimeSeriesPlotConfig)
+        }
+
+    __slots__: List[str] = ['_variable_name', '_enabled', '_y_axis_id', '_type']
+
+    def __init__(self, type: "scout_chartdefinition_api_TimeSeriesPlotConfig", variable_name: str, y_axis_id: str, enabled: Optional[bool] = None) -> None:
+        self._variable_name = variable_name
+        self._enabled = enabled
+        self._y_axis_id = y_axis_id
+        self._type = type
+
+    @builtins.property
+    def variable_name(self) -> str:
+        return self._variable_name
+
+    @builtins.property
+    def enabled(self) -> Optional[bool]:
+        return self._enabled
+
+    @builtins.property
+    def y_axis_id(self) -> str:
+        return self._y_axis_id
+
+    @builtins.property
+    def type(self) -> "scout_chartdefinition_api_TimeSeriesPlotConfig":
+        return self._type
+
+
+scout_chartdefinition_api_TimeSeriesPlotV2.__name__ = "TimeSeriesPlotV2"
+scout_chartdefinition_api_TimeSeriesPlotV2.__qualname__ = "TimeSeriesPlotV2"
+scout_chartdefinition_api_TimeSeriesPlotV2.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
+class scout_chartdefinition_api_TimeSeriesRangePlot(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'color': ConjureFieldDefinition('color', scout_api_HexColor)
+        }
+
+    __slots__: List[str] = ['_color']
+
+    def __init__(self, color: str) -> None:
+        self._color = color
+
+    @builtins.property
+    def color(self) -> str:
+        return self._color
+
+
+scout_chartdefinition_api_TimeSeriesRangePlot.__name__ = "TimeSeriesRangePlot"
+scout_chartdefinition_api_TimeSeriesRangePlot.__qualname__ = "TimeSeriesRangePlot"
+scout_chartdefinition_api_TimeSeriesRangePlot.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
 class scout_chartdefinition_api_TimeSeriesRow(ConjureBeanType):
 
     @builtins.classmethod
@@ -24577,15 +25163,17 @@ class scout_chartdefinition_api_TimeSeriesRow(ConjureBeanType):
         return {
             'title': ConjureFieldDefinition('title', OptionalTypeWrapper[str]),
             'plots': ConjureFieldDefinition('plots', List[scout_chartdefinition_api_TimeSeriesPlot]),
+            'plots_v2': ConjureFieldDefinition('plotsV2', OptionalTypeWrapper[List[scout_chartdefinition_api_TimeSeriesPlotV2]]),
             'row_flex_size': ConjureFieldDefinition('rowFlexSize', float),
             'enabled': ConjureFieldDefinition('enabled', OptionalTypeWrapper[bool])
         }
 
-    __slots__: List[str] = ['_title', '_plots', '_row_flex_size', '_enabled']
+    __slots__: List[str] = ['_title', '_plots', '_plots_v2', '_row_flex_size', '_enabled']
 
-    def __init__(self, plots: List["scout_chartdefinition_api_TimeSeriesPlot"], row_flex_size: float, enabled: Optional[bool] = None, title: Optional[str] = None) -> None:
+    def __init__(self, plots: List["scout_chartdefinition_api_TimeSeriesPlot"], row_flex_size: float, enabled: Optional[bool] = None, plots_v2: Optional[List["scout_chartdefinition_api_TimeSeriesPlotV2"]] = None, title: Optional[str] = None) -> None:
         self._title = title
         self._plots = plots
+        self._plots_v2 = plots_v2
         self._row_flex_size = row_flex_size
         self._enabled = enabled
 
@@ -24597,6 +25185,10 @@ class scout_chartdefinition_api_TimeSeriesRow(ConjureBeanType):
     def plots(self) -> List["scout_chartdefinition_api_TimeSeriesPlot"]:
         return self._plots
 
+    @builtins.property
+    def plots_v2(self) -> Optional[List["scout_chartdefinition_api_TimeSeriesPlotV2"]]:
+        return self._plots_v2
+
     @builtins.property
     def row_flex_size(self) -> float:
         return self._row_flex_size
@@ -26899,6 +27491,10 @@ class scout_checklistexecution_api_InvalidStreamingComputeNode(ConjureEnumType):
     '''INTEGRAL'''
     STALENESS_DETECTION = 'STALENESS_DETECTION'
     '''STALENESS_DETECTION'''
+    LITERAL_RANGES = 'LITERAL_RANGES'
+    '''LITERAL_RANGES'''
+    TIME_RANGE_FILTER = 'TIME_RANGE_FILTER'
+    '''TIME_RANGE_FILTER'''
     UNKNOWN = 'UNKNOWN'
     '''UNKNOWN'''
 
@@ -38927,6 +39523,64 @@ scout_compute_api_LatLongPoint.__qualname__ = "LatLongPoint"
 scout_compute_api_LatLongPoint.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_LiteralRange(ConjureBeanType):
+    """
+    A literal range of values.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'start_timestamp': ConjureFieldDefinition('startTimestamp', OptionalTypeWrapper[scout_compute_api_TimestampConstant]),
+            'end_timestamp': ConjureFieldDefinition('endTimestamp', OptionalTypeWrapper[scout_compute_api_TimestampConstant])
+        }
+
+    __slots__: List[str] = ['_start_timestamp', '_end_timestamp']
+
+    def __init__(self, end_timestamp: Optional["scout_compute_api_TimestampConstant"] = None, start_timestamp: Optional["scout_compute_api_TimestampConstant"] = None) -> None:
+        self._start_timestamp = start_timestamp
+        self._end_timestamp = end_timestamp
+
+    @builtins.property
+    def start_timestamp(self) -> Optional["scout_compute_api_TimestampConstant"]:
+        return self._start_timestamp
+
+    @builtins.property
+    def end_timestamp(self) -> Optional["scout_compute_api_TimestampConstant"]:
+        return self._end_timestamp
+
+
+scout_compute_api_LiteralRange.__name__ = "LiteralRange"
+scout_compute_api_LiteralRange.__qualname__ = "LiteralRange"
+scout_compute_api_LiteralRange.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_LiteralRanges(ConjureBeanType):
+    """
+    A list of literal ranges.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'literal_ranges': ConjureFieldDefinition('literalRanges', List[scout_compute_api_LiteralRange])
+        }
+
+    __slots__: List[str] = ['_literal_ranges']
+
+    def __init__(self, literal_ranges: List["scout_compute_api_LiteralRange"]) -> None:
+        self._literal_ranges = literal_ranges
+
+    @builtins.property
+    def literal_ranges(self) -> List["scout_compute_api_LiteralRange"]:
+        return self._literal_ranges
+
+
+scout_compute_api_LiteralRanges.__name__ = "LiteralRanges"
+scout_compute_api_LiteralRanges.__qualname__ = "LiteralRanges"
+scout_compute_api_LiteralRanges.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_LogExactMatchCaseInsensitiveFilter(ConjureBeanType):
     """
     Filters points such that the log message in each point contains an exact case-insensitive match of the
@@ -42268,6 +42922,7 @@ class scout_compute_api_RangeSeries(ConjureUnionType):
     _enum_series_equality_ranges_node: Optional["scout_compute_api_EnumSeriesEqualityRanges"] = None
     _function: Optional["scout_compute_api_RangesFunction"] = None
     _intersect_range: Optional["scout_compute_api_IntersectRanges"] = None
+    _literal_ranges: Optional["scout_compute_api_LiteralRanges"] = None
     _min_max_threshold: Optional["scout_compute_api_MinMaxThresholdRanges"] = None
     _not_: Optional["scout_compute_api_NotRanges"] = None
     _on_change: Optional["scout_compute_api_OnChangeRanges"] = None
@@ -42289,6 +42944,7 @@ class scout_compute_api_RangeSeries(ConjureUnionType):
             'enum_series_equality_ranges_node': ConjureFieldDefinition('enumSeriesEqualityRangesNode', scout_compute_api_EnumSeriesEqualityRanges),
             'function': ConjureFieldDefinition('function', scout_compute_api_RangesFunction),
             'intersect_range': ConjureFieldDefinition('intersectRange', scout_compute_api_IntersectRanges),
+            'literal_ranges': ConjureFieldDefinition('literalRanges', scout_compute_api_LiteralRanges),
             'min_max_threshold': ConjureFieldDefinition('minMaxThreshold', scout_compute_api_MinMaxThresholdRanges),
             'not_': ConjureFieldDefinition('not', scout_compute_api_NotRanges),
             'on_change': ConjureFieldDefinition('onChange', scout_compute_api_OnChangeRanges),
@@ -42310,6 +42966,7 @@ class scout_compute_api_RangeSeries(ConjureUnionType):
             enum_series_equality_ranges_node: Optional["scout_compute_api_EnumSeriesEqualityRanges"] = None,
             function: Optional["scout_compute_api_RangesFunction"] = None,
             intersect_range: Optional["scout_compute_api_IntersectRanges"] = None,
+            literal_ranges: Optional["scout_compute_api_LiteralRanges"] = None,
             min_max_threshold: Optional["scout_compute_api_MinMaxThresholdRanges"] = None,
             not_: Optional["scout_compute_api_NotRanges"] = None,
             on_change: Optional["scout_compute_api_OnChangeRanges"] = None,
@@ -42325,7 +42982,7 @@ class scout_compute_api_RangeSeries(ConjureUnionType):
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (approximate_threshold is not None) + (enum_filter is not None) + (enum_series_equality_ranges_node is not None) + (function is not None) + (intersect_range is not None) + (min_max_threshold is not None) + (not_ is not None) + (on_change is not None) + (peak is not None) + (range_numeric_aggregation is not None) + (raw is not None) + (series_crossover_ranges_node is not None) + (series_equality_ranges_node is not None) + (stability_detection is not None) + (stale_range is not None) + (threshold is not None) + (union_range is not None) != 1:
+            if (approximate_threshold is not None) + (enum_filter is not None) + (enum_series_equality_ranges_node is not None) + (function is not None) + (intersect_range is not None) + (literal_ranges is not None) + (min_max_threshold is not None) + (not_ is not None) + (on_change is not None) + (peak is not None) + (range_numeric_aggregation is not None) + (raw is not None) + (series_crossover_ranges_node is not None) + (series_equality_ranges_node is not None) + (stability_detection is not None) + (stale_range is not None) + (threshold is not None) + (union_range is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if approximate_threshold is not None:
@@ -42343,6 +43000,9 @@ class scout_compute_api_RangeSeries(ConjureUnionType):
             if intersect_range is not None:
                 self._intersect_range = intersect_range
                 self._type = 'intersectRange'
+            if literal_ranges is not None:
+                self._literal_ranges = literal_ranges
+                self._type = 'literalRanges'
             if min_max_threshold is not None:
                 self._min_max_threshold = min_max_threshold
                 self._type = 'minMaxThreshold'
@@ -42405,6 +43065,11 @@ class scout_compute_api_RangeSeries(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._intersect_range = intersect_range
             self._type = 'intersectRange'
+        elif type_of_union == 'literalRanges':
+            if literal_ranges is None:
+                raise ValueError('a union value must not be None')
+            self._literal_ranges = literal_ranges
+            self._type = 'literalRanges'
         elif type_of_union == 'minMaxThreshold':
             if min_max_threshold is None:
                 raise ValueError('a union value must not be None')
@@ -42486,6 +43151,10 @@ class scout_compute_api_RangeSeries(ConjureUnionType):
     def intersect_range(self) -> Optional["scout_compute_api_IntersectRanges"]:
         return self._intersect_range
 
+    @builtins.property
+    def literal_ranges(self) -> Optional["scout_compute_api_LiteralRanges"]:
+        return self._literal_ranges
+
     @builtins.property
     def min_max_threshold(self) -> Optional["scout_compute_api_MinMaxThresholdRanges"]:
         """
@@ -42553,6 +43222,8 @@ class scout_compute_api_RangeSeries(ConjureUnionType):
             return visitor._function(self.function)
         if self._type == 'intersectRange' and self.intersect_range is not None:
             return visitor._intersect_range(self.intersect_range)
+        if self._type == 'literalRanges' and self.literal_ranges is not None:
+            return visitor._literal_ranges(self.literal_ranges)
         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:
@@ -42606,6 +43277,10 @@ class scout_compute_api_RangeSeriesVisitor:
     def _intersect_range(self, intersect_range: "scout_compute_api_IntersectRanges") -> Any:
         pass
 
+    @abstractmethod
+    def _literal_ranges(self, literal_ranges: "scout_compute_api_LiteralRanges") -> Any:
+        pass
+
     @abstractmethod
     def _min_max_threshold(self, min_max_threshold: "scout_compute_api_MinMaxThresholdRanges") -> Any:
         pass
@@ -49844,6 +50519,58 @@ 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
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'start_timestamp': ConjureFieldDefinition('startTimestamp', OptionalTypeWrapper[api_Timestamp]),
+            'end_timestamp': ConjureFieldDefinition('endTimestamp', OptionalTypeWrapper[api_Timestamp])
+        }
+
+    __slots__: List[str] = ['_start_timestamp', '_end_timestamp']
+
+    def __init__(self, end_timestamp: Optional["api_Timestamp"] = None, start_timestamp: Optional["api_Timestamp"] = None) -> None:
+        self._start_timestamp = start_timestamp
+        self._end_timestamp = end_timestamp
+
+    @builtins.property
+    def start_timestamp(self) -> Optional["api_Timestamp"]:
+        return self._start_timestamp
+
+    @builtins.property
+    def end_timestamp(self) -> Optional["api_Timestamp"]:
+        return self._end_timestamp
+
+
+scout_compute_resolved_api_LiteralRange.__name__ = "LiteralRange"
+scout_compute_resolved_api_LiteralRange.__qualname__ = "LiteralRange"
+scout_compute_resolved_api_LiteralRange.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
+class scout_compute_resolved_api_LiteralRangesNode(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'literal_ranges': ConjureFieldDefinition('literalRanges', List[scout_compute_resolved_api_LiteralRange])
+        }
+
+    __slots__: List[str] = ['_literal_ranges']
+
+    def __init__(self, literal_ranges: List["scout_compute_resolved_api_LiteralRange"]) -> None:
+        self._literal_ranges = literal_ranges
+
+    @builtins.property
+    def literal_ranges(self) -> List["scout_compute_resolved_api_LiteralRange"]:
+        return self._literal_ranges
+
+
+scout_compute_resolved_api_LiteralRangesNode.__name__ = "LiteralRangesNode"
+scout_compute_resolved_api_LiteralRangesNode.__qualname__ = "LiteralRangesNode"
+scout_compute_resolved_api_LiteralRangesNode.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
 class scout_compute_resolved_api_LogFilterSeriesNode(ConjureBeanType):
 
     @builtins.classmethod
@@ -51402,6 +52129,7 @@ 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
+    _literal_ranges: Optional["scout_compute_resolved_api_LiteralRangesNode"] = 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
@@ -51419,6 +52147,7 @@ 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),
+            'literal_ranges': ConjureFieldDefinition('literalRanges', scout_compute_resolved_api_LiteralRangesNode),
             '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),
@@ -51436,6 +52165,7 @@ 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,
+            literal_ranges: Optional["scout_compute_resolved_api_LiteralRangesNode"] = 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,
@@ -51448,7 +52178,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) + (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) + (literal_ranges 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:
@@ -51463,6 +52193,9 @@ class scout_compute_resolved_api_RangesNode(ConjureUnionType):
             if intersect_range is not None:
                 self._intersect_range = intersect_range
                 self._type = 'intersectRange'
+            if literal_ranges is not None:
+                self._literal_ranges = literal_ranges
+                self._type = 'literalRanges'
             if min_max_threshold is not None:
                 self._min_max_threshold = min_max_threshold
                 self._type = 'minMaxThreshold'
@@ -51511,6 +52244,11 @@ 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 == 'literalRanges':
+            if literal_ranges is None:
+                raise ValueError('a union value must not be None')
+            self._literal_ranges = literal_ranges
+            self._type = 'literalRanges'
         elif type_of_union == 'minMaxThreshold':
             if min_max_threshold is None:
                 raise ValueError('a union value must not be None')
@@ -51573,6 +52311,10 @@ class scout_compute_resolved_api_RangesNode(ConjureUnionType):
     def intersect_range(self) -> Optional["scout_compute_resolved_api_IntersectRangesNode"]:
         return self._intersect_range
 
+    @builtins.property
+    def literal_ranges(self) -> Optional["scout_compute_resolved_api_LiteralRangesNode"]:
+        return self._literal_ranges
+
     @builtins.property
     def min_max_threshold(self) -> Optional["scout_compute_resolved_api_MinMaxThresholdRangesNode"]:
         return self._min_max_threshold
@@ -51620,6 +52362,8 @@ 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 == 'literalRanges' and self.literal_ranges is not None:
+            return visitor._literal_ranges(self.literal_ranges)
         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:
@@ -51663,6 +52407,10 @@ class scout_compute_resolved_api_RangesNodeVisitor:
     def _intersect_range(self, intersect_range: "scout_compute_resolved_api_IntersectRangesNode") -> Any:
         pass
 
+    @abstractmethod
+    def _literal_ranges(self, literal_ranges: "scout_compute_resolved_api_LiteralRangesNode") -> Any:
+        pass
+
     @abstractmethod
     def _min_max_threshold(self, min_max_threshold: "scout_compute_resolved_api_MinMaxThresholdRangesNode") -> Any:
         pass
@@ -56378,17 +57126,21 @@ class scout_datareview_api_DataReview(ConjureBeanType):
             'created_at': ConjureFieldDefinition('createdAt', str),
             'created_by': ConjureFieldDefinition('createdBy', scout_rids_api_UserRid),
             'checklist': ConjureFieldDefinition('checklist', scout_datareview_api_ChecklistEvaluation),
+            'checklist_ref': ConjureFieldDefinition('checklistRef', scout_checks_api_PinnedChecklistRef),
+            'check_evaluations': ConjureFieldDefinition('checkEvaluations', List[scout_datareview_api_AutomaticCheckEvaluation]),
             'archived': ConjureFieldDefinition('archived', bool)
         }
 
-    __slots__: List[str] = ['_rid', '_run_rid', '_created_at', '_created_by', '_checklist', '_archived']
+    __slots__: List[str] = ['_rid', '_run_rid', '_created_at', '_created_by', '_checklist', '_checklist_ref', '_check_evaluations', '_archived']
 
-    def __init__(self, archived: bool, checklist: "scout_datareview_api_ChecklistEvaluation", created_at: str, created_by: str, rid: str, run_rid: str) -> None:
+    def __init__(self, archived: bool, check_evaluations: List["scout_datareview_api_AutomaticCheckEvaluation"], checklist: "scout_datareview_api_ChecklistEvaluation", checklist_ref: "scout_checks_api_PinnedChecklistRef", created_at: str, created_by: str, rid: str, run_rid: str) -> None:
         self._rid = rid
         self._run_rid = run_rid
         self._created_at = created_at
         self._created_by = created_by
         self._checklist = checklist
+        self._checklist_ref = checklist_ref
+        self._check_evaluations = check_evaluations
         self._archived = archived
 
     @builtins.property
@@ -56411,6 +57163,14 @@ class scout_datareview_api_DataReview(ConjureBeanType):
     def checklist(self) -> "scout_datareview_api_ChecklistEvaluation":
         return self._checklist
 
+    @builtins.property
+    def checklist_ref(self) -> "scout_checks_api_PinnedChecklistRef":
+        return self._checklist_ref
+
+    @builtins.property
+    def check_evaluations(self) -> List["scout_datareview_api_AutomaticCheckEvaluation"]:
+        return self._check_evaluations
+
     @builtins.property
     def archived(self) -> bool:
         return self._archived
@@ -72796,18 +73556,27 @@ class scout_workbookcommon_api_EventReference(ConjureBeanType):
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'event_uuid': ConjureFieldDefinition('eventUuid', str)
+            'event_uuid': ConjureFieldDefinition('eventUuid', str),
+            'rid': ConjureFieldDefinition('rid', OptionalTypeWrapper[api_rids_EventRid])
         }
 
-    __slots__: List[str] = ['_event_uuid']
+    __slots__: List[str] = ['_event_uuid', '_rid']
 
-    def __init__(self, event_uuid: str) -> None:
+    def __init__(self, event_uuid: str, rid: Optional[str] = None) -> None:
         self._event_uuid = event_uuid
+        self._rid = rid
 
     @builtins.property
     def event_uuid(self) -> str:
         return self._event_uuid
 
+    @builtins.property
+    def rid(self) -> Optional[str]:
+        """
+        The event's unique identifier. This will soon be a required field.
+        """
+        return self._rid
+
 
 scout_workbookcommon_api_EventReference.__name__ = "EventReference"
 scout_workbookcommon_api_EventReference.__qualname__ = "EventReference"
@@ -73786,42 +74555,42 @@ security_api_workspace_UpdateOrRemoveWorkspaceDisplayNameVisitor.__qualname__ =
 security_api_workspace_UpdateOrRemoveWorkspaceDisplayNameVisitor.__module__ = "nominal_api.security_api_workspace"
 
 
-class security_api_workspace_UpdateOrRemoveWorkspaceIconUrl(ConjureUnionType):
-    """The request to update the icon url of the workspace. The request will replace the existing icon url
-with the icon url specified if it's provided. Otherwise, the current icon url will be removed from
+class security_api_workspace_UpdateOrRemoveWorkspaceSymbol(ConjureUnionType):
+    """The request to update the symbol of the workspace. The request will replace the existing symbol
+with the symbol specified if it's provided. Otherwise, the current symbol will be removed from
 the workspace."""
-    _icon_url: Optional[str] = None
+    _symbol: Optional["security_api_workspace_WorkspaceSymbol"] = None
     _remove_type: Optional["security_api_workspace_RemoveType"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'icon_url': ConjureFieldDefinition('iconUrl', str),
+            'symbol': ConjureFieldDefinition('symbol', security_api_workspace_WorkspaceSymbol),
             'remove_type': ConjureFieldDefinition('removeType', security_api_workspace_RemoveType)
         }
 
     def __init__(
             self,
-            icon_url: Optional[str] = None,
+            symbol: Optional["security_api_workspace_WorkspaceSymbol"] = None,
             remove_type: Optional["security_api_workspace_RemoveType"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (icon_url is not None) + (remove_type is not None) != 1:
+            if (symbol is not None) + (remove_type is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
-            if icon_url is not None:
-                self._icon_url = icon_url
-                self._type = 'iconUrl'
+            if symbol is not None:
+                self._symbol = symbol
+                self._type = 'symbol'
             if remove_type is not None:
                 self._remove_type = remove_type
                 self._type = 'removeType'
 
-        elif type_of_union == 'iconUrl':
-            if icon_url is None:
+        elif type_of_union == 'symbol':
+            if symbol is None:
                 raise ValueError('a union value must not be None')
-            self._icon_url = icon_url
-            self._type = 'iconUrl'
+            self._symbol = symbol
+            self._type = 'symbol'
         elif type_of_union == 'removeType':
             if remove_type is None:
                 raise ValueError('a union value must not be None')
@@ -73829,31 +74598,31 @@ the workspace."""
             self._type = 'removeType'
 
     @builtins.property
-    def icon_url(self) -> Optional[str]:
-        return self._icon_url
+    def symbol(self) -> Optional["security_api_workspace_WorkspaceSymbol"]:
+        return self._symbol
 
     @builtins.property
     def remove_type(self) -> Optional["security_api_workspace_RemoveType"]:
         return self._remove_type
 
     def accept(self, visitor) -> Any:
-        if not isinstance(visitor, security_api_workspace_UpdateOrRemoveWorkspaceIconUrlVisitor):
-            raise ValueError('{} is not an instance of security_api_workspace_UpdateOrRemoveWorkspaceIconUrlVisitor'.format(visitor.__class__.__name__))
-        if self._type == 'iconUrl' and self.icon_url is not None:
-            return visitor._icon_url(self.icon_url)
+        if not isinstance(visitor, security_api_workspace_UpdateOrRemoveWorkspaceSymbolVisitor):
+            raise ValueError('{} is not an instance of security_api_workspace_UpdateOrRemoveWorkspaceSymbolVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'symbol' and self.symbol is not None:
+            return visitor._symbol(self.symbol)
         if self._type == 'removeType' and self.remove_type is not None:
             return visitor._remove_type(self.remove_type)
 
 
-security_api_workspace_UpdateOrRemoveWorkspaceIconUrl.__name__ = "UpdateOrRemoveWorkspaceIconUrl"
-security_api_workspace_UpdateOrRemoveWorkspaceIconUrl.__qualname__ = "UpdateOrRemoveWorkspaceIconUrl"
-security_api_workspace_UpdateOrRemoveWorkspaceIconUrl.__module__ = "nominal_api.security_api_workspace"
+security_api_workspace_UpdateOrRemoveWorkspaceSymbol.__name__ = "UpdateOrRemoveWorkspaceSymbol"
+security_api_workspace_UpdateOrRemoveWorkspaceSymbol.__qualname__ = "UpdateOrRemoveWorkspaceSymbol"
+security_api_workspace_UpdateOrRemoveWorkspaceSymbol.__module__ = "nominal_api.security_api_workspace"
 
 
-class security_api_workspace_UpdateOrRemoveWorkspaceIconUrlVisitor:
+class security_api_workspace_UpdateOrRemoveWorkspaceSymbolVisitor:
 
     @abstractmethod
-    def _icon_url(self, icon_url: str) -> Any:
+    def _symbol(self, symbol: "security_api_workspace_WorkspaceSymbol") -> Any:
         pass
 
     @abstractmethod
@@ -73861,9 +74630,9 @@ class security_api_workspace_UpdateOrRemoveWorkspaceIconUrlVisitor:
         pass
 
 
-security_api_workspace_UpdateOrRemoveWorkspaceIconUrlVisitor.__name__ = "UpdateOrRemoveWorkspaceIconUrlVisitor"
-security_api_workspace_UpdateOrRemoveWorkspaceIconUrlVisitor.__qualname__ = "UpdateOrRemoveWorkspaceIconUrlVisitor"
-security_api_workspace_UpdateOrRemoveWorkspaceIconUrlVisitor.__module__ = "nominal_api.security_api_workspace"
+security_api_workspace_UpdateOrRemoveWorkspaceSymbolVisitor.__name__ = "UpdateOrRemoveWorkspaceSymbolVisitor"
+security_api_workspace_UpdateOrRemoveWorkspaceSymbolVisitor.__qualname__ = "UpdateOrRemoveWorkspaceSymbolVisitor"
+security_api_workspace_UpdateOrRemoveWorkspaceSymbolVisitor.__module__ = "nominal_api.security_api_workspace"
 
 
 class security_api_workspace_UpdateWorkspaceRequest(ConjureBeanType):
@@ -73872,22 +74641,22 @@ class security_api_workspace_UpdateWorkspaceRequest(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'display_name': ConjureFieldDefinition('displayName', OptionalTypeWrapper[security_api_workspace_UpdateOrRemoveWorkspaceDisplayName]),
-            'icon_url': ConjureFieldDefinition('iconUrl', OptionalTypeWrapper[security_api_workspace_UpdateOrRemoveWorkspaceIconUrl])
+            'symbol': ConjureFieldDefinition('symbol', OptionalTypeWrapper[security_api_workspace_UpdateOrRemoveWorkspaceSymbol])
         }
 
-    __slots__: List[str] = ['_display_name', '_icon_url']
+    __slots__: List[str] = ['_display_name', '_symbol']
 
-    def __init__(self, display_name: Optional["security_api_workspace_UpdateOrRemoveWorkspaceDisplayName"] = None, icon_url: Optional["security_api_workspace_UpdateOrRemoveWorkspaceIconUrl"] = None) -> None:
+    def __init__(self, display_name: Optional["security_api_workspace_UpdateOrRemoveWorkspaceDisplayName"] = None, symbol: Optional["security_api_workspace_UpdateOrRemoveWorkspaceSymbol"] = None) -> None:
         self._display_name = display_name
-        self._icon_url = icon_url
+        self._symbol = symbol
 
     @builtins.property
     def display_name(self) -> Optional["security_api_workspace_UpdateOrRemoveWorkspaceDisplayName"]:
         return self._display_name
 
     @builtins.property
-    def icon_url(self) -> Optional["security_api_workspace_UpdateOrRemoveWorkspaceIconUrl"]:
-        return self._icon_url
+    def symbol(self) -> Optional["security_api_workspace_UpdateOrRemoveWorkspaceSymbol"]:
+        return self._symbol
 
 
 security_api_workspace_UpdateWorkspaceRequest.__name__ = "UpdateWorkspaceRequest"
@@ -73904,17 +74673,17 @@ class security_api_workspace_Workspace(ConjureBeanType):
             'rid': ConjureFieldDefinition('rid', api_rids_WorkspaceRid),
             'org': ConjureFieldDefinition('org', authentication_api_OrgRid),
             'display_name': ConjureFieldDefinition('displayName', OptionalTypeWrapper[str]),
-            'icon_url': ConjureFieldDefinition('iconUrl', OptionalTypeWrapper[str])
+            'symbol': ConjureFieldDefinition('symbol', OptionalTypeWrapper[security_api_workspace_WorkspaceSymbol])
         }
 
-    __slots__: List[str] = ['_id', '_rid', '_org', '_display_name', '_icon_url']
+    __slots__: List[str] = ['_id', '_rid', '_org', '_display_name', '_symbol']
 
-    def __init__(self, id: str, org: str, rid: str, display_name: Optional[str] = None, icon_url: Optional[str] = None) -> None:
+    def __init__(self, id: str, org: str, rid: str, display_name: Optional[str] = None, symbol: Optional["security_api_workspace_WorkspaceSymbol"] = None) -> None:
         self._id = id
         self._rid = rid
         self._org = org
         self._display_name = display_name
-        self._icon_url = icon_url
+        self._symbol = symbol
 
     @builtins.property
     def id(self) -> str:
@@ -73936,11 +74705,8 @@ class security_api_workspace_Workspace(ConjureBeanType):
         return self._display_name
 
     @builtins.property
-    def icon_url(self) -> Optional[str]:
-        """
-        URL to the icon for the workspace.
-        """
-        return self._icon_url
+    def symbol(self) -> Optional["security_api_workspace_WorkspaceSymbol"]:
+        return self._symbol
 
 
 security_api_workspace_Workspace.__name__ = "Workspace"
@@ -74089,6 +74855,113 @@ security_api_workspace_WorkspaceService.__qualname__ = "WorkspaceService"
 security_api_workspace_WorkspaceService.__module__ = "nominal_api.security_api_workspace"
 
 
+class security_api_workspace_WorkspaceSymbol(ConjureUnionType):
+    _icon: Optional[str] = None
+    _emoji: Optional[str] = None
+    _image: Optional[str] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'icon': ConjureFieldDefinition('icon', str),
+            'emoji': ConjureFieldDefinition('emoji', str),
+            'image': ConjureFieldDefinition('image', str)
+        }
+
+    def __init__(
+            self,
+            icon: Optional[str] = None,
+            emoji: Optional[str] = None,
+            image: Optional[str] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (icon is not None) + (emoji is not None) + (image is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if icon is not None:
+                self._icon = icon
+                self._type = 'icon'
+            if emoji is not None:
+                self._emoji = emoji
+                self._type = 'emoji'
+            if image is not None:
+                self._image = image
+                self._type = 'image'
+
+        elif type_of_union == 'icon':
+            if icon is None:
+                raise ValueError('a union value must not be None')
+            self._icon = icon
+            self._type = 'icon'
+        elif type_of_union == 'emoji':
+            if emoji is None:
+                raise ValueError('a union value must not be None')
+            self._emoji = emoji
+            self._type = 'emoji'
+        elif type_of_union == 'image':
+            if image is None:
+                raise ValueError('a union value must not be None')
+            self._image = image
+            self._type = 'image'
+
+    @builtins.property
+    def icon(self) -> Optional[str]:
+        """
+        Workspace icon name (e.g. castle)
+        """
+        return self._icon
+
+    @builtins.property
+    def emoji(self) -> Optional[str]:
+        """
+        Workspace emoji name (e.g. :castle:)
+        """
+        return self._emoji
+
+    @builtins.property
+    def image(self) -> Optional[str]:
+        """
+        Workspace image url (e.g. https://example.com/image.png)
+        """
+        return self._image
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, security_api_workspace_WorkspaceSymbolVisitor):
+            raise ValueError('{} is not an instance of security_api_workspace_WorkspaceSymbolVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'icon' and self.icon is not None:
+            return visitor._icon(self.icon)
+        if self._type == 'emoji' and self.emoji is not None:
+            return visitor._emoji(self.emoji)
+        if self._type == 'image' and self.image is not None:
+            return visitor._image(self.image)
+
+
+security_api_workspace_WorkspaceSymbol.__name__ = "WorkspaceSymbol"
+security_api_workspace_WorkspaceSymbol.__qualname__ = "WorkspaceSymbol"
+security_api_workspace_WorkspaceSymbol.__module__ = "nominal_api.security_api_workspace"
+
+
+class security_api_workspace_WorkspaceSymbolVisitor:
+
+    @abstractmethod
+    def _icon(self, icon: str) -> Any:
+        pass
+
+    @abstractmethod
+    def _emoji(self, emoji: str) -> Any:
+        pass
+
+    @abstractmethod
+    def _image(self, image: str) -> Any:
+        pass
+
+
+security_api_workspace_WorkspaceSymbolVisitor.__name__ = "WorkspaceSymbolVisitor"
+security_api_workspace_WorkspaceSymbolVisitor.__qualname__ = "WorkspaceSymbolVisitor"
+security_api_workspace_WorkspaceSymbolVisitor.__module__ = "nominal_api.security_api_workspace"
+
+
 class storage_datasource_api_CreateNominalDataSourceRequest(ConjureBeanType):
 
     @builtins.classmethod