nominal-api 0.655.0__tar.gz → 0.656.0__tar.gz

{nominal_api-0.655.0 → nominal_api-0.656.0}/PKG-INFO

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

{nominal_api-0.655.0 → nominal_api-0.656.0}/nominal_api/__init__.py

@@ -75,5 +75,5 @@ __all__ = [
 
 __conjure_generator_version__ = "4.9.0"
 
-__version__ = "0.655.0"
+__version__ = "0.656.0"
 

{nominal_api-0.655.0 → nominal_api-0.656.0}/nominal_api/_impl.py

@@ -22256,6 +22256,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 +24094,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 +24341,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 +24758,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 +24898,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 +25067,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 +25089,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

{nominal_api-0.655.0 → nominal_api-0.656.0}/nominal_api/scout_chartdefinition_api/__init__.py

@@ -21,6 +21,8 @@ from .._impl import (
     scout_chartdefinition_api_ChecklistChartDefinition as ChecklistChartDefinition,
     scout_chartdefinition_api_ChecklistChartDefinitionV1 as ChecklistChartDefinitionV1,
     scout_chartdefinition_api_ChecklistChartDefinitionVisitor as ChecklistChartDefinitionVisitor,
+    scout_chartdefinition_api_ColorStyle as ColorStyle,
+    scout_chartdefinition_api_ColorStyleVisitor as ColorStyleVisitor,
     scout_chartdefinition_api_DataSourceRefName as DataSourceRefName,
     scout_chartdefinition_api_DefaultFill as DefaultFill,
     scout_chartdefinition_api_EnumCellConfig as EnumCellConfig,
@@ -79,10 +81,16 @@ from .._impl import (
     scout_chartdefinition_api_NumericValueVisualisationV2 as NumericValueVisualisationV2,
     scout_chartdefinition_api_NumericValueVisualisationV2Visitor as NumericValueVisualisationV2Visitor,
     scout_chartdefinition_api_NumericValueVisualisationVisitor as NumericValueVisualisationVisitor,
+    scout_chartdefinition_api_OverlayScope as OverlayScope,
+    scout_chartdefinition_api_PersistAll as PersistAll,
+    scout_chartdefinition_api_PersistByValue as PersistByValue,
+    scout_chartdefinition_api_PersistValueOverlay as PersistValueOverlay,
+    scout_chartdefinition_api_PersistValueOverlayVisitor as PersistValueOverlayVisitor,
     scout_chartdefinition_api_PlotlyPanelDefinition as PlotlyPanelDefinition,
     scout_chartdefinition_api_PlotlyPanelDefinitionV1 as PlotlyPanelDefinitionV1,
     scout_chartdefinition_api_PlotlyPanelDefinitionVisitor as PlotlyPanelDefinitionVisitor,
     scout_chartdefinition_api_PlotlyPreset as PlotlyPreset,
+    scout_chartdefinition_api_Position as Position,
     scout_chartdefinition_api_RangeCellConfig as RangeCellConfig,
     scout_chartdefinition_api_RangeRawVisualisation as RangeRawVisualisation,
     scout_chartdefinition_api_RangeValueChannel as RangeValueChannel,
@@ -96,7 +104,13 @@ from .._impl import (
     scout_chartdefinition_api_TimeSeriesChartDefinition as TimeSeriesChartDefinition,
     scout_chartdefinition_api_TimeSeriesChartDefinitionV1 as TimeSeriesChartDefinitionV1,
     scout_chartdefinition_api_TimeSeriesChartDefinitionVisitor as TimeSeriesChartDefinitionVisitor,
+    scout_chartdefinition_api_TimeSeriesEnumPlot as TimeSeriesEnumPlot,
+    scout_chartdefinition_api_TimeSeriesNumericPlot as TimeSeriesNumericPlot,
     scout_chartdefinition_api_TimeSeriesPlot as TimeSeriesPlot,
+    scout_chartdefinition_api_TimeSeriesPlotConfig as TimeSeriesPlotConfig,
+    scout_chartdefinition_api_TimeSeriesPlotConfigVisitor as TimeSeriesPlotConfigVisitor,
+    scout_chartdefinition_api_TimeSeriesPlotV2 as TimeSeriesPlotV2,
+    scout_chartdefinition_api_TimeSeriesRangePlot as TimeSeriesRangePlot,
     scout_chartdefinition_api_TimeSeriesRow as TimeSeriesRow,
     scout_chartdefinition_api_Trace as Trace,
     scout_chartdefinition_api_TraceCompute as TraceCompute,

{nominal_api-0.655.0 → nominal_api-0.656.0}/nominal_api.egg-info/PKG-INFO

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

{nominal_api-0.655.0 → nominal_api-0.656.0}/setup.py

@@ -6,7 +6,7 @@ from setuptools import (
 
 setup(
     name='nominal-api',
-    version='0.655.0',
+    version='0.656.0',
     python_requires='>=3.8',
     package_data={"": ["py.typed"]},
     packages=find_packages(),