nominal-api 0.534.0__py3-none-any.whl → 0.536.0__py3-none-any.whl

nominal_api/__init__.py

@@ -68,5 +68,5 @@ __all__ = [
 
 __conjure_generator_version__ = "4.9.0"
 
-__version__ = "0.534.0"
+__version__ = "0.536.0"
 

nominal_api/_impl.py

@@ -5126,8 +5126,6 @@ class event_CreateEvent(ConjureBeanType):
         return {
             'asset_rids': ConjureFieldDefinition('assetRids', List[scout_rids_api_AssetRid]),
             'origins': ConjureFieldDefinition('origins', List[event_EventOrigin]),
-            'associations': ConjureFieldDefinition('associations', List[str]),
-            'authorization_rid': ConjureFieldDefinition('authorizationRid', OptionalTypeWrapper[str]),
             'timestamp': ConjureFieldDefinition('timestamp', api_Timestamp),
             'duration': ConjureFieldDefinition('duration', scout_run_api_Duration),
             'name': ConjureFieldDefinition('name', str),
@@ -5136,13 +5134,11 @@ class event_CreateEvent(ConjureBeanType):
             'properties': ConjureFieldDefinition('properties', Dict[scout_run_api_PropertyName, scout_run_api_PropertyValue])
         }
 
-    __slots__: List[str] = ['_asset_rids', '_origins', '_associations', '_authorization_rid', '_timestamp', '_duration', '_name', '_type', '_labels', '_properties']
+    __slots__: List[str] = ['_asset_rids', '_origins', '_timestamp', '_duration', '_name', '_type', '_labels', '_properties']
 
-    def __init__(self, asset_rids: List[str], associations: List[str], duration: "scout_run_api_Duration", labels: List[str], name: str, origins: List["event_EventOrigin"], properties: Dict[str, str], timestamp: "api_Timestamp", type: "event_EventType", authorization_rid: Optional[str] = None) -> None:
+    def __init__(self, asset_rids: List[str], duration: "scout_run_api_Duration", labels: List[str], name: str, origins: List["event_EventOrigin"], properties: Dict[str, str], timestamp: "api_Timestamp", type: "event_EventType") -> None:
         self._asset_rids = asset_rids
         self._origins = origins
-        self._associations = associations
-        self._authorization_rid = authorization_rid
         self._timestamp = timestamp
         self._duration = duration
         self._name = name
@@ -5160,18 +5156,10 @@ class event_CreateEvent(ConjureBeanType):
     @builtins.property
     def origins(self) -> List["event_EventOrigin"]:
         """
-        If empty, will default to set<EventOrigin.api>. Should be nonempty, but not enforced yet.
+        If empty, will default to set<EventOrigin.api>.
         """
         return self._origins
 
-    @builtins.property
-    def associations(self) -> List[str]:
-        return self._associations
-
-    @builtins.property
-    def authorization_rid(self) -> Optional[str]:
-        return self._authorization_rid
-
     @builtins.property
     def timestamp(self) -> "api_Timestamp":
         return self._timestamp
@@ -5210,7 +5198,6 @@ class event_Event(ConjureBeanType):
             'uuid': ConjureFieldDefinition('uuid', str),
             'asset_rids': ConjureFieldDefinition('assetRids', List[scout_rids_api_AssetRid]),
             'origins': ConjureFieldDefinition('origins', List[event_EventOrigin]),
-            'authorization_rid': ConjureFieldDefinition('authorizationRid', OptionalTypeWrapper[str]),
             'timestamp': ConjureFieldDefinition('timestamp', api_Timestamp),
             'duration': ConjureFieldDefinition('duration', scout_run_api_Duration),
             'name': ConjureFieldDefinition('name', str),
@@ -5218,16 +5205,15 @@ class event_Event(ConjureBeanType):
             'labels': ConjureFieldDefinition('labels', List[scout_run_api_Label]),
             'properties': ConjureFieldDefinition('properties', Dict[scout_run_api_PropertyName, scout_run_api_PropertyValue]),
             'is_archived': ConjureFieldDefinition('isArchived', bool),
-            'created_by': ConjureFieldDefinition('createdBy', scout_rids_api_UserRid)
+            'created_by': ConjureFieldDefinition('createdBy', OptionalTypeWrapper[scout_rids_api_UserRid])
         }
 
-    __slots__: List[str] = ['_uuid', '_asset_rids', '_origins', '_authorization_rid', '_timestamp', '_duration', '_name', '_type', '_labels', '_properties', '_is_archived', '_created_by']
+    __slots__: List[str] = ['_uuid', '_asset_rids', '_origins', '_timestamp', '_duration', '_name', '_type', '_labels', '_properties', '_is_archived', '_created_by']
 
-    def __init__(self, asset_rids: List[str], created_by: str, duration: "scout_run_api_Duration", is_archived: bool, labels: List[str], name: str, origins: List["event_EventOrigin"], properties: Dict[str, str], timestamp: "api_Timestamp", type: "event_EventType", uuid: str, authorization_rid: Optional[str] = None) -> None:
+    def __init__(self, asset_rids: List[str], duration: "scout_run_api_Duration", is_archived: bool, labels: List[str], name: str, origins: List["event_EventOrigin"], properties: Dict[str, str], timestamp: "api_Timestamp", type: "event_EventType", uuid: str, created_by: Optional[str] = None) -> None:
         self._uuid = uuid
         self._asset_rids = asset_rids
         self._origins = origins
-        self._authorization_rid = authorization_rid
         self._timestamp = timestamp
         self._duration = duration
         self._name = name
@@ -5255,14 +5241,6 @@ class event_Event(ConjureBeanType):
         """
         return self._origins
 
-    @builtins.property
-    def authorization_rid(self) -> Optional[str]:
-        """
-        A user authorized for this rid can access the event. 
-Can be a workbook rid, asset rid, etc.
-        """
-        return self._authorization_rid
-
     @builtins.property
     def timestamp(self) -> "api_Timestamp":
         return self._timestamp
@@ -5292,10 +5270,10 @@ Can be a workbook rid, asset rid, etc.
         return self._is_archived
 
     @builtins.property
-    def created_by(self) -> str:
+    def created_by(self) -> Optional[str]:
         """
         The user who created the event.
-This field may be inaccurate for historical events.
+This field may be missing for legacy events.
         """
         return self._created_by
 
@@ -5546,7 +5524,7 @@ The Event Service is responsible for creating and retrieving events for a partic
 
         return
 
-    def search_events(self, auth_header: str, list_runs_request: "event_SearchEventsRequest") -> "event_SearchEventsResponse":
+    def search_events(self, auth_header: str, request: "event_SearchEventsRequest") -> "event_SearchEventsResponse":
         """
         Searches for events that match the given filters.
         """
@@ -5563,7 +5541,7 @@ The Event Service is responsible for creating and retrieving events for a partic
         _path_params: Dict[str, Any] = {
         }
 
-        _json: Any = ConjureEncoder().default(list_runs_request)
+        _json: Any = ConjureEncoder().default(request)
 
         _path = '/event/v1/search-events'
         _path = _path.format(**_path_params)
@@ -5995,7 +5973,6 @@ class event_UpdateEvent(ConjureBeanType):
         return {
             'uuid': ConjureFieldDefinition('uuid', str),
             'asset_rids': ConjureFieldDefinition('assetRids', OptionalTypeWrapper[List[scout_rids_api_AssetRid]]),
-            'authorization_rid': ConjureFieldDefinition('authorizationRid', OptionalTypeWrapper[str]),
             'timestamp': ConjureFieldDefinition('timestamp', OptionalTypeWrapper[api_Timestamp]),
             'duration': ConjureFieldDefinition('duration', OptionalTypeWrapper[scout_run_api_Duration]),
             'name': ConjureFieldDefinition('name', OptionalTypeWrapper[str]),
@@ -6004,12 +5981,11 @@ class event_UpdateEvent(ConjureBeanType):
             'properties': ConjureFieldDefinition('properties', OptionalTypeWrapper[Dict[scout_run_api_PropertyName, scout_run_api_PropertyValue]])
         }
 
-    __slots__: List[str] = ['_uuid', '_asset_rids', '_authorization_rid', '_timestamp', '_duration', '_name', '_type', '_labels', '_properties']
+    __slots__: List[str] = ['_uuid', '_asset_rids', '_timestamp', '_duration', '_name', '_type', '_labels', '_properties']
 
-    def __init__(self, uuid: str, asset_rids: Optional[List[str]] = None, authorization_rid: Optional[str] = None, duration: Optional["scout_run_api_Duration"] = None, labels: Optional[List[str]] = None, name: Optional[str] = None, properties: Optional[Dict[str, str]] = None, timestamp: Optional["api_Timestamp"] = None, type: Optional["event_EventType"] = None) -> None:
+    def __init__(self, uuid: str, asset_rids: Optional[List[str]] = None, duration: Optional["scout_run_api_Duration"] = None, labels: Optional[List[str]] = None, name: Optional[str] = None, properties: Optional[Dict[str, str]] = None, timestamp: Optional["api_Timestamp"] = None, type: Optional["event_EventType"] = None) -> None:
         self._uuid = uuid
         self._asset_rids = asset_rids
-        self._authorization_rid = authorization_rid
         self._timestamp = timestamp
         self._duration = duration
         self._name = name
@@ -6029,10 +6005,6 @@ If provided, must contain at least one asset rid.
         """
         return self._asset_rids
 
-    @builtins.property
-    def authorization_rid(self) -> Optional[str]:
-        return self._authorization_rid
-
     @builtins.property
     def timestamp(self) -> Optional["api_Timestamp"]:
         return self._timestamp
@@ -17490,6 +17462,29 @@ scout_chartdefinition_api_DefaultFill.__qualname__ = "DefaultFill"
 scout_chartdefinition_api_DefaultFill.__module__ = "nominal_api.scout_chartdefinition_api"
 
 
+class scout_chartdefinition_api_EnumCellConfig(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'visualisation': ConjureFieldDefinition('visualisation', OptionalTypeWrapper[scout_chartdefinition_api_EnumValueVisualisation])
+        }
+
+    __slots__: List[str] = ['_visualisation']
+
+    def __init__(self, visualisation: Optional["scout_chartdefinition_api_EnumValueVisualisation"] = None) -> None:
+        self._visualisation = visualisation
+
+    @builtins.property
+    def visualisation(self) -> Optional["scout_chartdefinition_api_EnumValueVisualisation"]:
+        return self._visualisation
+
+
+scout_chartdefinition_api_EnumCellConfig.__name__ = "EnumCellConfig"
+scout_chartdefinition_api_EnumCellConfig.__qualname__ = "EnumCellConfig"
+scout_chartdefinition_api_EnumCellConfig.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
 class scout_chartdefinition_api_EnumRawVisualisation(ConjureBeanType):
     """
     The settings for a raw enum visualisation.
@@ -18565,6 +18560,58 @@ scout_chartdefinition_api_LineThresholdGroup.__qualname__ = "LineThresholdGroup"
 scout_chartdefinition_api_LineThresholdGroup.__module__ = "nominal_api.scout_chartdefinition_api"
 
 
+class scout_chartdefinition_api_NumberFormat(ConjureBeanType):
+    """
+    Number format for numeric cells, eg 1e4 | 10000 | 10,000.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'sig_figs': ConjureFieldDefinition('sigFigs', OptionalTypeWrapper[int]),
+            'display_option': ConjureFieldDefinition('displayOption', OptionalTypeWrapper[scout_chartdefinition_api_NumberFormatDisplayOption])
+        }
+
+    __slots__: List[str] = ['_sig_figs', '_display_option']
+
+    def __init__(self, display_option: Optional["scout_chartdefinition_api_NumberFormatDisplayOption"] = None, sig_figs: Optional[int] = None) -> None:
+        self._sig_figs = sig_figs
+        self._display_option = display_option
+
+    @builtins.property
+    def sig_figs(self) -> Optional[int]:
+        return self._sig_figs
+
+    @builtins.property
+    def display_option(self) -> Optional["scout_chartdefinition_api_NumberFormatDisplayOption"]:
+        return self._display_option
+
+
+scout_chartdefinition_api_NumberFormat.__name__ = "NumberFormat"
+scout_chartdefinition_api_NumberFormat.__qualname__ = "NumberFormat"
+scout_chartdefinition_api_NumberFormat.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
+class scout_chartdefinition_api_NumberFormatDisplayOption(ConjureEnumType):
+
+    SUCCINCT = 'SUCCINCT'
+    '''SUCCINCT'''
+    LOCALE = 'LOCALE'
+    '''LOCALE'''
+    PLAIN = 'PLAIN'
+    '''PLAIN'''
+    UNKNOWN = 'UNKNOWN'
+    '''UNKNOWN'''
+
+    def __reduce_ex__(self, proto):
+        return self.__class__, (self.name,)
+
+
+scout_chartdefinition_api_NumberFormatDisplayOption.__name__ = "NumberFormatDisplayOption"
+scout_chartdefinition_api_NumberFormatDisplayOption.__qualname__ = "NumberFormatDisplayOption"
+scout_chartdefinition_api_NumberFormatDisplayOption.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
 class scout_chartdefinition_api_NumericBarGaugeVisualisation(ConjureBeanType):
     """
     The settings for a bar gauge visualisation.
@@ -18597,6 +18644,69 @@ scout_chartdefinition_api_NumericBarGaugeVisualisation.__qualname__ = "NumericBa
 scout_chartdefinition_api_NumericBarGaugeVisualisation.__module__ = "nominal_api.scout_chartdefinition_api"
 
 
+class scout_chartdefinition_api_NumericBarVisualisationV2(ConjureBeanType):
+    """
+    A numeric visualisation that will fill the cell from left to right with a colored background
+representing where the value falls inside a set range. 
+The lowest and highest values in the thresholds determine the start and end of the range. 
+Middle threshold values will still affect the cell's coloration.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'thresholds': ConjureFieldDefinition('thresholds', OptionalTypeWrapper[List[scout_chartdefinition_api_Threshold]])
+        }
+
+    __slots__: List[str] = ['_thresholds']
+
+    def __init__(self, thresholds: Optional[List["scout_chartdefinition_api_Threshold"]] = None) -> None:
+        self._thresholds = thresholds
+
+    @builtins.property
+    def thresholds(self) -> Optional[List["scout_chartdefinition_api_Threshold"]]:
+        """
+        Modifies the visualisation based on the highest threshold value that
+the computed value equals or surpasses. The lowest and highest value will determine
+the 0% and 100% values of the bar.
+        """
+        return self._thresholds
+
+
+scout_chartdefinition_api_NumericBarVisualisationV2.__name__ = "NumericBarVisualisationV2"
+scout_chartdefinition_api_NumericBarVisualisationV2.__qualname__ = "NumericBarVisualisationV2"
+scout_chartdefinition_api_NumericBarVisualisationV2.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
+class scout_chartdefinition_api_NumericCellConfig(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'visualisation': ConjureFieldDefinition('visualisation', OptionalTypeWrapper[scout_chartdefinition_api_NumericValueVisualisationV2]),
+            'number_format': ConjureFieldDefinition('numberFormat', OptionalTypeWrapper[scout_chartdefinition_api_NumberFormat])
+        }
+
+    __slots__: List[str] = ['_visualisation', '_number_format']
+
+    def __init__(self, number_format: Optional["scout_chartdefinition_api_NumberFormat"] = None, visualisation: Optional["scout_chartdefinition_api_NumericValueVisualisationV2"] = None) -> None:
+        self._visualisation = visualisation
+        self._number_format = number_format
+
+    @builtins.property
+    def visualisation(self) -> Optional["scout_chartdefinition_api_NumericValueVisualisationV2"]:
+        return self._visualisation
+
+    @builtins.property
+    def number_format(self) -> Optional["scout_chartdefinition_api_NumberFormat"]:
+        return self._number_format
+
+
+scout_chartdefinition_api_NumericCellConfig.__name__ = "NumericCellConfig"
+scout_chartdefinition_api_NumericCellConfig.__qualname__ = "NumericCellConfig"
+scout_chartdefinition_api_NumericCellConfig.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
 class scout_chartdefinition_api_NumericRawVisualisation(ConjureBeanType):
 
     @builtins.classmethod
@@ -18613,6 +18723,36 @@ scout_chartdefinition_api_NumericRawVisualisation.__qualname__ = "NumericRawVisu
 scout_chartdefinition_api_NumericRawVisualisation.__module__ = "nominal_api.scout_chartdefinition_api"
 
 
+class scout_chartdefinition_api_NumericRawVisualisationV2(ConjureBeanType):
+    """
+    A raw numeric visualisation with optional coloring based on numeric thresholds.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'thresholds': ConjureFieldDefinition('thresholds', OptionalTypeWrapper[List[scout_chartdefinition_api_Threshold]])
+        }
+
+    __slots__: List[str] = ['_thresholds']
+
+    def __init__(self, thresholds: Optional[List["scout_chartdefinition_api_Threshold"]] = None) -> None:
+        self._thresholds = thresholds
+
+    @builtins.property
+    def thresholds(self) -> Optional[List["scout_chartdefinition_api_Threshold"]]:
+        """
+        Modifies the visualisation based on the highest threshold value that
+the computed value surpasses.
+        """
+        return self._thresholds
+
+
+scout_chartdefinition_api_NumericRawVisualisationV2.__name__ = "NumericRawVisualisationV2"
+scout_chartdefinition_api_NumericRawVisualisationV2.__qualname__ = "NumericRawVisualisationV2"
+scout_chartdefinition_api_NumericRawVisualisationV2.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
 class scout_chartdefinition_api_NumericValueChannel(ConjureBeanType):
 
     @builtins.classmethod
@@ -18719,6 +18859,106 @@ scout_chartdefinition_api_NumericValueVisualisationVisitor.__qualname__ = "Numer
 scout_chartdefinition_api_NumericValueVisualisationVisitor.__module__ = "nominal_api.scout_chartdefinition_api"
 
 
+class scout_chartdefinition_api_NumericValueVisualisationV2(ConjureUnionType):
+    _raw: Optional["scout_chartdefinition_api_NumericRawVisualisationV2"] = None
+    _bar: Optional["scout_chartdefinition_api_NumericBarVisualisationV2"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'raw': ConjureFieldDefinition('raw', scout_chartdefinition_api_NumericRawVisualisationV2),
+            'bar': ConjureFieldDefinition('bar', scout_chartdefinition_api_NumericBarVisualisationV2)
+        }
+
+    def __init__(
+            self,
+            raw: Optional["scout_chartdefinition_api_NumericRawVisualisationV2"] = None,
+            bar: Optional["scout_chartdefinition_api_NumericBarVisualisationV2"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (raw is not None) + (bar is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if raw is not None:
+                self._raw = raw
+                self._type = 'raw'
+            if bar is not None:
+                self._bar = bar
+                self._type = 'bar'
+
+        elif type_of_union == 'raw':
+            if raw is None:
+                raise ValueError('a union value must not be None')
+            self._raw = raw
+            self._type = 'raw'
+        elif type_of_union == 'bar':
+            if bar is None:
+                raise ValueError('a union value must not be None')
+            self._bar = bar
+            self._type = 'bar'
+
+    @builtins.property
+    def raw(self) -> Optional["scout_chartdefinition_api_NumericRawVisualisationV2"]:
+        return self._raw
+
+    @builtins.property
+    def bar(self) -> Optional["scout_chartdefinition_api_NumericBarVisualisationV2"]:
+        return self._bar
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_chartdefinition_api_NumericValueVisualisationV2Visitor):
+            raise ValueError('{} is not an instance of scout_chartdefinition_api_NumericValueVisualisationV2Visitor'.format(visitor.__class__.__name__))
+        if self._type == 'raw' and self.raw is not None:
+            return visitor._raw(self.raw)
+        if self._type == 'bar' and self.bar is not None:
+            return visitor._bar(self.bar)
+
+
+scout_chartdefinition_api_NumericValueVisualisationV2.__name__ = "NumericValueVisualisationV2"
+scout_chartdefinition_api_NumericValueVisualisationV2.__qualname__ = "NumericValueVisualisationV2"
+scout_chartdefinition_api_NumericValueVisualisationV2.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
+class scout_chartdefinition_api_NumericValueVisualisationV2Visitor:
+
+    @abstractmethod
+    def _raw(self, raw: "scout_chartdefinition_api_NumericRawVisualisationV2") -> Any:
+        pass
+
+    @abstractmethod
+    def _bar(self, bar: "scout_chartdefinition_api_NumericBarVisualisationV2") -> Any:
+        pass
+
+
+scout_chartdefinition_api_NumericValueVisualisationV2Visitor.__name__ = "NumericValueVisualisationV2Visitor"
+scout_chartdefinition_api_NumericValueVisualisationV2Visitor.__qualname__ = "NumericValueVisualisationV2Visitor"
+scout_chartdefinition_api_NumericValueVisualisationV2Visitor.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
+class scout_chartdefinition_api_RangeCellConfig(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'visualisation': ConjureFieldDefinition('visualisation', OptionalTypeWrapper[scout_chartdefinition_api_RangeValueVisualisation])
+        }
+
+    __slots__: List[str] = ['_visualisation']
+
+    def __init__(self, visualisation: Optional["scout_chartdefinition_api_RangeValueVisualisation"] = None) -> None:
+        self._visualisation = visualisation
+
+    @builtins.property
+    def visualisation(self) -> Optional["scout_chartdefinition_api_RangeValueVisualisation"]:
+        return self._visualisation
+
+
+scout_chartdefinition_api_RangeCellConfig.__name__ = "RangeCellConfig"
+scout_chartdefinition_api_RangeCellConfig.__qualname__ = "RangeCellConfig"
+scout_chartdefinition_api_RangeCellConfig.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
 class scout_chartdefinition_api_RangeRawVisualisation(ConjureBeanType):
     """
     The settings for a raw range visualisation.
@@ -18836,6 +19076,50 @@ scout_chartdefinition_api_RangeValueVisualisationVisitor.__qualname__ = "RangeVa
 scout_chartdefinition_api_RangeValueVisualisationVisitor.__module__ = "nominal_api.scout_chartdefinition_api"
 
 
+class scout_chartdefinition_api_Threshold(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'value': ConjureFieldDefinition('value', float),
+            'color': ConjureFieldDefinition('color', scout_api_HexColor),
+            'label': ConjureFieldDefinition('label', OptionalTypeWrapper[str])
+        }
+
+    __slots__: List[str] = ['_value', '_color', '_label']
+
+    def __init__(self, color: str, value: float, label: Optional[str] = None) -> None:
+        self._value = value
+        self._color = color
+        self._label = label
+
+    @builtins.property
+    def value(self) -> float:
+        """
+        The minimum value a number must be to .
+        """
+        return self._value
+
+    @builtins.property
+    def color(self) -> str:
+        """
+        The color to apply to the cell when the threshold is active.
+        """
+        return self._color
+
+    @builtins.property
+    def label(self) -> Optional[str]:
+        """
+        A name for this threshold to display while editing.
+        """
+        return self._label
+
+
+scout_chartdefinition_api_Threshold.__name__ = "Threshold"
+scout_chartdefinition_api_Threshold.__qualname__ = "Threshold"
+scout_chartdefinition_api_Threshold.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
 class scout_chartdefinition_api_ThresholdLineStyle(ConjureEnumType):
 
     DOTTED = 'DOTTED'
@@ -19130,6 +19414,133 @@ scout_chartdefinition_api_ValueAxis.__qualname__ = "ValueAxis"
 scout_chartdefinition_api_ValueAxis.__module__ = "nominal_api.scout_chartdefinition_api"
 
 
+class scout_chartdefinition_api_ValueTableCell(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'variable_name': ConjureFieldDefinition('variableName', str),
+            'config': ConjureFieldDefinition('config', scout_chartdefinition_api_ValueTableCellConfig)
+        }
+
+    __slots__: List[str] = ['_variable_name', '_config']
+
+    def __init__(self, config: "scout_chartdefinition_api_ValueTableCellConfig", variable_name: str) -> None:
+        self._variable_name = variable_name
+        self._config = config
+
+    @builtins.property
+    def variable_name(self) -> str:
+        return self._variable_name
+
+    @builtins.property
+    def config(self) -> "scout_chartdefinition_api_ValueTableCellConfig":
+        return self._config
+
+
+scout_chartdefinition_api_ValueTableCell.__name__ = "ValueTableCell"
+scout_chartdefinition_api_ValueTableCell.__qualname__ = "ValueTableCell"
+scout_chartdefinition_api_ValueTableCell.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
+class scout_chartdefinition_api_ValueTableCellConfig(ConjureUnionType):
+    _numeric: Optional["scout_chartdefinition_api_NumericCellConfig"] = None
+    _enum: Optional["scout_chartdefinition_api_EnumCellConfig"] = None
+    _range: Optional["scout_chartdefinition_api_RangeCellConfig"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'numeric': ConjureFieldDefinition('numeric', scout_chartdefinition_api_NumericCellConfig),
+            'enum': ConjureFieldDefinition('enum', scout_chartdefinition_api_EnumCellConfig),
+            'range': ConjureFieldDefinition('range', scout_chartdefinition_api_RangeCellConfig)
+        }
+
+    def __init__(
+            self,
+            numeric: Optional["scout_chartdefinition_api_NumericCellConfig"] = None,
+            enum: Optional["scout_chartdefinition_api_EnumCellConfig"] = None,
+            range: Optional["scout_chartdefinition_api_RangeCellConfig"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (numeric is not None) + (enum is not None) + (range 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 enum is not None:
+                self._enum = enum
+                self._type = 'enum'
+            if range is not None:
+                self._range = range
+                self._type = 'range'
+
+        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 == 'enum':
+            if enum is None:
+                raise ValueError('a union value must not be None')
+            self._enum = enum
+            self._type = 'enum'
+        elif type_of_union == 'range':
+            if range is None:
+                raise ValueError('a union value must not be None')
+            self._range = range
+            self._type = 'range'
+
+    @builtins.property
+    def numeric(self) -> Optional["scout_chartdefinition_api_NumericCellConfig"]:
+        return self._numeric
+
+    @builtins.property
+    def enum(self) -> Optional["scout_chartdefinition_api_EnumCellConfig"]:
+        return self._enum
+
+    @builtins.property
+    def range(self) -> Optional["scout_chartdefinition_api_RangeCellConfig"]:
+        return self._range
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_chartdefinition_api_ValueTableCellConfigVisitor):
+            raise ValueError('{} is not an instance of scout_chartdefinition_api_ValueTableCellConfigVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'numeric' and self.numeric is not None:
+            return visitor._numeric(self.numeric)
+        if self._type == 'enum' and self.enum is not None:
+            return visitor._enum(self.enum)
+        if self._type == 'range' and self.range is not None:
+            return visitor._range(self.range)
+
+
+scout_chartdefinition_api_ValueTableCellConfig.__name__ = "ValueTableCellConfig"
+scout_chartdefinition_api_ValueTableCellConfig.__qualname__ = "ValueTableCellConfig"
+scout_chartdefinition_api_ValueTableCellConfig.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
+class scout_chartdefinition_api_ValueTableCellConfigVisitor:
+
+    @abstractmethod
+    def _numeric(self, numeric: "scout_chartdefinition_api_NumericCellConfig") -> Any:
+        pass
+
+    @abstractmethod
+    def _enum(self, enum: "scout_chartdefinition_api_EnumCellConfig") -> Any:
+        pass
+
+    @abstractmethod
+    def _range(self, range: "scout_chartdefinition_api_RangeCellConfig") -> Any:
+        pass
+
+
+scout_chartdefinition_api_ValueTableCellConfigVisitor.__name__ = "ValueTableCellConfigVisitor"
+scout_chartdefinition_api_ValueTableCellConfigVisitor.__qualname__ = "ValueTableCellConfigVisitor"
+scout_chartdefinition_api_ValueTableCellConfigVisitor.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
 class scout_chartdefinition_api_ValueTableChannel(ConjureUnionType):
     _numeric: Optional["scout_chartdefinition_api_NumericValueChannel"] = None
     _enum: Optional["scout_chartdefinition_api_EnumValueChannel"] = None
@@ -19230,41 +19641,58 @@ scout_chartdefinition_api_ValueTableChannelVisitor.__module__ = "nominal_api.sco
 
 class scout_chartdefinition_api_ValueTableDefinition(ConjureUnionType):
     _v1: Optional["scout_chartdefinition_api_ValueTableDefinitionV1"] = None
+    _v2: Optional["scout_chartdefinition_api_ValueTableDefinitionV2"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'v1': ConjureFieldDefinition('v1', scout_chartdefinition_api_ValueTableDefinitionV1)
+            'v1': ConjureFieldDefinition('v1', scout_chartdefinition_api_ValueTableDefinitionV1),
+            'v2': ConjureFieldDefinition('v2', scout_chartdefinition_api_ValueTableDefinitionV2)
         }
 
     def __init__(
             self,
             v1: Optional["scout_chartdefinition_api_ValueTableDefinitionV1"] = None,
+            v2: Optional["scout_chartdefinition_api_ValueTableDefinitionV2"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (v1 is not None) != 1:
+            if (v1 is not None) + (v2 is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if v1 is not None:
                 self._v1 = v1
                 self._type = 'v1'
+            if v2 is not None:
+                self._v2 = v2
+                self._type = 'v2'
 
         elif type_of_union == 'v1':
             if v1 is None:
                 raise ValueError('a union value must not be None')
             self._v1 = v1
             self._type = 'v1'
+        elif type_of_union == 'v2':
+            if v2 is None:
+                raise ValueError('a union value must not be None')
+            self._v2 = v2
+            self._type = 'v2'
 
     @builtins.property
     def v1(self) -> Optional["scout_chartdefinition_api_ValueTableDefinitionV1"]:
         return self._v1
 
+    @builtins.property
+    def v2(self) -> Optional["scout_chartdefinition_api_ValueTableDefinitionV2"]:
+        return self._v2
+
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, scout_chartdefinition_api_ValueTableDefinitionVisitor):
             raise ValueError('{} is not an instance of scout_chartdefinition_api_ValueTableDefinitionVisitor'.format(visitor.__class__.__name__))
         if self._type == 'v1' and self.v1 is not None:
             return visitor._v1(self.v1)
+        if self._type == 'v2' and self.v2 is not None:
+            return visitor._v2(self.v2)
 
 
 scout_chartdefinition_api_ValueTableDefinition.__name__ = "ValueTableDefinition"
@@ -19278,6 +19706,10 @@ class scout_chartdefinition_api_ValueTableDefinitionVisitor:
     def _v1(self, v1: "scout_chartdefinition_api_ValueTableDefinitionV1") -> Any:
         pass
 
+    @abstractmethod
+    def _v2(self, v2: "scout_chartdefinition_api_ValueTableDefinitionV2") -> Any:
+        pass
+
 
 scout_chartdefinition_api_ValueTableDefinitionVisitor.__name__ = "ValueTableDefinitionVisitor"
 scout_chartdefinition_api_ValueTableDefinitionVisitor.__qualname__ = "ValueTableDefinitionVisitor"
@@ -19317,6 +19749,312 @@ scout_chartdefinition_api_ValueTableDefinitionV1.__qualname__ = "ValueTableDefin
 scout_chartdefinition_api_ValueTableDefinitionV1.__module__ = "nominal_api.scout_chartdefinition_api"
 
 
+class scout_chartdefinition_api_ValueTableDefinitionV2(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'title': ConjureFieldDefinition('title', OptionalTypeWrapper[str]),
+            'show_units': ConjureFieldDefinition('showUnits', OptionalTypeWrapper[bool]),
+            'layout': ConjureFieldDefinition('layout', scout_chartdefinition_api_ValueTableLayout)
+        }
+
+    __slots__: List[str] = ['_title', '_show_units', '_layout']
+
+    def __init__(self, layout: "scout_chartdefinition_api_ValueTableLayout", show_units: Optional[bool] = None, title: Optional[str] = None) -> None:
+        self._title = title
+        self._show_units = show_units
+        self._layout = layout
+
+    @builtins.property
+    def title(self) -> Optional[str]:
+        """
+        The display title of the panel.
+        """
+        return self._title
+
+    @builtins.property
+    def show_units(self) -> Optional[bool]:
+        """
+        If true, display units in the cells when available.
+        """
+        return self._show_units
+
+    @builtins.property
+    def layout(self) -> "scout_chartdefinition_api_ValueTableLayout":
+        return self._layout
+
+
+scout_chartdefinition_api_ValueTableDefinitionV2.__name__ = "ValueTableDefinitionV2"
+scout_chartdefinition_api_ValueTableDefinitionV2.__qualname__ = "ValueTableDefinitionV2"
+scout_chartdefinition_api_ValueTableDefinitionV2.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
+class scout_chartdefinition_api_ValueTableGridRowColumnConfig(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'position': ConjureFieldDefinition('position', int),
+            'header': ConjureFieldDefinition('header', OptionalTypeWrapper[str]),
+            'cell_config': ConjureFieldDefinition('cellConfig', OptionalTypeWrapper[scout_chartdefinition_api_ValueTableMultiCellConfig])
+        }
+
+    __slots__: List[str] = ['_position', '_header', '_cell_config']
+
+    def __init__(self, position: int, cell_config: Optional["scout_chartdefinition_api_ValueTableMultiCellConfig"] = None, header: Optional[str] = None) -> None:
+        self._position = position
+        self._header = header
+        self._cell_config = cell_config
+
+    @builtins.property
+    def position(self) -> int:
+        """
+        The index of the row or column to apply this configuration to.
+        """
+        return self._position
+
+    @builtins.property
+    def header(self) -> Optional[str]:
+        return self._header
+
+    @builtins.property
+    def cell_config(self) -> Optional["scout_chartdefinition_api_ValueTableMultiCellConfig"]:
+        return self._cell_config
+
+
+scout_chartdefinition_api_ValueTableGridRowColumnConfig.__name__ = "ValueTableGridRowColumnConfig"
+scout_chartdefinition_api_ValueTableGridRowColumnConfig.__qualname__ = "ValueTableGridRowColumnConfig"
+scout_chartdefinition_api_ValueTableGridRowColumnConfig.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
+class scout_chartdefinition_api_ValueTableGridValueTableCell(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'row': ConjureFieldDefinition('row', int),
+            'column': ConjureFieldDefinition('column', int),
+            'cell': ConjureFieldDefinition('cell', scout_chartdefinition_api_ValueTableCell)
+        }
+
+    __slots__: List[str] = ['_row', '_column', '_cell']
+
+    def __init__(self, cell: "scout_chartdefinition_api_ValueTableCell", column: int, row: int) -> None:
+        self._row = row
+        self._column = column
+        self._cell = cell
+
+    @builtins.property
+    def row(self) -> int:
+        return self._row
+
+    @builtins.property
+    def column(self) -> int:
+        return self._column
+
+    @builtins.property
+    def cell(self) -> "scout_chartdefinition_api_ValueTableCell":
+        return self._cell
+
+
+scout_chartdefinition_api_ValueTableGridValueTableCell.__name__ = "ValueTableGridValueTableCell"
+scout_chartdefinition_api_ValueTableGridValueTableCell.__qualname__ = "ValueTableGridValueTableCell"
+scout_chartdefinition_api_ValueTableGridValueTableCell.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
+class scout_chartdefinition_api_ValueTableLayout(ConjureUnionType):
+    _grid: Optional["scout_chartdefinition_api_ValueTableLayoutGrid"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'grid': ConjureFieldDefinition('grid', scout_chartdefinition_api_ValueTableLayoutGrid)
+        }
+
+    def __init__(
+            self,
+            grid: Optional["scout_chartdefinition_api_ValueTableLayoutGrid"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (grid is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if grid is not None:
+                self._grid = grid
+                self._type = 'grid'
+
+        elif type_of_union == 'grid':
+            if grid is None:
+                raise ValueError('a union value must not be None')
+            self._grid = grid
+            self._type = 'grid'
+
+    @builtins.property
+    def grid(self) -> Optional["scout_chartdefinition_api_ValueTableLayoutGrid"]:
+        return self._grid
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_chartdefinition_api_ValueTableLayoutVisitor):
+            raise ValueError('{} is not an instance of scout_chartdefinition_api_ValueTableLayoutVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'grid' and self.grid is not None:
+            return visitor._grid(self.grid)
+
+
+scout_chartdefinition_api_ValueTableLayout.__name__ = "ValueTableLayout"
+scout_chartdefinition_api_ValueTableLayout.__qualname__ = "ValueTableLayout"
+scout_chartdefinition_api_ValueTableLayout.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
+class scout_chartdefinition_api_ValueTableLayoutVisitor:
+
+    @abstractmethod
+    def _grid(self, grid: "scout_chartdefinition_api_ValueTableLayoutGrid") -> Any:
+        pass
+
+
+scout_chartdefinition_api_ValueTableLayoutVisitor.__name__ = "ValueTableLayoutVisitor"
+scout_chartdefinition_api_ValueTableLayoutVisitor.__qualname__ = "ValueTableLayoutVisitor"
+scout_chartdefinition_api_ValueTableLayoutVisitor.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
+class scout_chartdefinition_api_ValueTableLayoutGrid(ConjureBeanType):
+    """
+    A 2D grid layout for the value table where cells are laid out in specific
+rows and columns. Supports hierarchical cell visualisation configurations, favoring when present:
+the cell's own definition, then the column's, then the row's, then the panel's.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'show_row_headers': ConjureFieldDefinition('showRowHeaders', OptionalTypeWrapper[bool]),
+            'show_column_headers': ConjureFieldDefinition('showColumnHeaders', OptionalTypeWrapper[bool]),
+            'show_cell_labels': ConjureFieldDefinition('showCellLabels', OptionalTypeWrapper[bool]),
+            'grid_default_cell_configs': ConjureFieldDefinition('gridDefaultCellConfigs', scout_chartdefinition_api_ValueTableMultiCellConfig),
+            'column_configs': ConjureFieldDefinition('columnConfigs', List[scout_chartdefinition_api_ValueTableGridRowColumnConfig]),
+            'row_configs': ConjureFieldDefinition('rowConfigs', List[scout_chartdefinition_api_ValueTableGridRowColumnConfig]),
+            'row_count': ConjureFieldDefinition('rowCount', int),
+            'column_count': ConjureFieldDefinition('columnCount', int),
+            'cells': ConjureFieldDefinition('cells', List[scout_chartdefinition_api_ValueTableGridValueTableCell])
+        }
+
+    __slots__: List[str] = ['_show_row_headers', '_show_column_headers', '_show_cell_labels', '_grid_default_cell_configs', '_column_configs', '_row_configs', '_row_count', '_column_count', '_cells']
+
+    def __init__(self, cells: List["scout_chartdefinition_api_ValueTableGridValueTableCell"], column_configs: List["scout_chartdefinition_api_ValueTableGridRowColumnConfig"], column_count: int, grid_default_cell_configs: "scout_chartdefinition_api_ValueTableMultiCellConfig", row_configs: List["scout_chartdefinition_api_ValueTableGridRowColumnConfig"], row_count: int, show_cell_labels: Optional[bool] = None, show_column_headers: Optional[bool] = None, show_row_headers: Optional[bool] = None) -> None:
+        self._show_row_headers = show_row_headers
+        self._show_column_headers = show_column_headers
+        self._show_cell_labels = show_cell_labels
+        self._grid_default_cell_configs = grid_default_cell_configs
+        self._column_configs = column_configs
+        self._row_configs = row_configs
+        self._row_count = row_count
+        self._column_count = column_count
+        self._cells = cells
+
+    @builtins.property
+    def show_row_headers(self) -> Optional[bool]:
+        """
+        If true, display row headers.
+        """
+        return self._show_row_headers
+
+    @builtins.property
+    def show_column_headers(self) -> Optional[bool]:
+        """
+        If true, display column headers.
+        """
+        return self._show_column_headers
+
+    @builtins.property
+    def show_cell_labels(self) -> Optional[bool]:
+        """
+        If true, display channel names in the cells.
+        """
+        return self._show_cell_labels
+
+    @builtins.property
+    def grid_default_cell_configs(self) -> "scout_chartdefinition_api_ValueTableMultiCellConfig":
+        """
+        Panel-level defaults for cell visualisations
+        """
+        return self._grid_default_cell_configs
+
+    @builtins.property
+    def column_configs(self) -> List["scout_chartdefinition_api_ValueTableGridRowColumnConfig"]:
+        """
+        Column-level configurations.
+        """
+        return self._column_configs
+
+    @builtins.property
+    def row_configs(self) -> List["scout_chartdefinition_api_ValueTableGridRowColumnConfig"]:
+        """
+        Row-level configurations.
+        """
+        return self._row_configs
+
+    @builtins.property
+    def row_count(self) -> int:
+        return self._row_count
+
+    @builtins.property
+    def column_count(self) -> int:
+        return self._column_count
+
+    @builtins.property
+    def cells(self) -> List["scout_chartdefinition_api_ValueTableGridValueTableCell"]:
+        """
+        An array of cells to display in the table.
+        """
+        return self._cells
+
+
+scout_chartdefinition_api_ValueTableLayoutGrid.__name__ = "ValueTableLayoutGrid"
+scout_chartdefinition_api_ValueTableLayoutGrid.__qualname__ = "ValueTableLayoutGrid"
+scout_chartdefinition_api_ValueTableLayoutGrid.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
+class scout_chartdefinition_api_ValueTableMultiCellConfig(ConjureBeanType):
+    """
+    Configurations for each type of cell in a grouping of heterogenous cells, such as
+for a row, for a column, or for the entire grid.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'range': ConjureFieldDefinition('range', OptionalTypeWrapper[scout_chartdefinition_api_RangeCellConfig]),
+            'enum': ConjureFieldDefinition('enum', OptionalTypeWrapper[scout_chartdefinition_api_EnumCellConfig]),
+            'numeric': ConjureFieldDefinition('numeric', OptionalTypeWrapper[scout_chartdefinition_api_NumericCellConfig])
+        }
+
+    __slots__: List[str] = ['_range', '_enum', '_numeric']
+
+    def __init__(self, enum: Optional["scout_chartdefinition_api_EnumCellConfig"] = None, numeric: Optional["scout_chartdefinition_api_NumericCellConfig"] = None, range: Optional["scout_chartdefinition_api_RangeCellConfig"] = None) -> None:
+        self._range = range
+        self._enum = enum
+        self._numeric = numeric
+
+    @builtins.property
+    def range(self) -> Optional["scout_chartdefinition_api_RangeCellConfig"]:
+        return self._range
+
+    @builtins.property
+    def enum(self) -> Optional["scout_chartdefinition_api_EnumCellConfig"]:
+        return self._enum
+
+    @builtins.property
+    def numeric(self) -> Optional["scout_chartdefinition_api_NumericCellConfig"]:
+        return self._numeric
+
+
+scout_chartdefinition_api_ValueTableMultiCellConfig.__name__ = "ValueTableMultiCellConfig"
+scout_chartdefinition_api_ValueTableMultiCellConfig.__qualname__ = "ValueTableMultiCellConfig"
+scout_chartdefinition_api_ValueTableMultiCellConfig.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
 class scout_chartdefinition_api_ValueToColorMap(ConjureUnionType):
     """Specifies an assignment of colors across several values."""
     _numeric: Optional[Dict[str, float]] = None
@@ -63060,6 +63798,86 @@ See: https://github.com/vectordotdev/vector/issues/8279
         _decoder = ConjureDecoder()
         return _decoder.decode(_response.json(), bool, self._return_none_for_unknown_union_types)
 
+    def write_nominal_batches(self, auth_header: str, data_source_rid: str, request: Any) -> None:
+        """
+        Synchronously writes a Nominal Write Request to a Nominal data source using the NominalWrite Protobuf schema.
+The request must be Protobuf-encoded and accompanied by the appropriate content encoding headers if compressed.
+
+The request should follow this Protobuf schema:
+```proto
+message WriteRequestNominal {
+  repeated Series series = 1;
+}
+
+message Series {
+  Channel channel = 1;            
+  map<string, string> tags = 2;   // Key-value pairs for series tags
+  Points points = 3;              // Contains either double or string points
+}
+
+message Points {
+  oneof points_type {
+    DoublePoints double_points = 1;
+    StringPoints string_points = 2;
+  }
+}
+
+message DoublePoints {
+  repeated DoublePoint points = 1;
+}
+
+message StringPoints {
+  repeated StringPoint points = 1;
+}
+
+message DoublePoint {
+  google.protobuf.Timestamp timestamp = 1;
+  double value = 2;
+}
+
+message StringPoint {
+  google.protobuf.Timestamp timestamp = 1;
+  string value = 2;
+}
+```
+
+Each request can contain multiple series, where each series consists of:
+- A channel name
+- A map of tags (key-value pairs)
+- A collection of points, which can be either double or string values
+- Each point includes a timestamp (using google.protobuf.Timestamp) and its value
+
+The endpoint requires the Content-Type header to be set to "application/x-protobuf".
+If the payload is compressed, the appropriate Content-Encoding header must be included.
+        """
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/octet-stream',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+            'dataSourceRid': data_source_rid,
+        }
+
+        _data: Any = request
+
+        _path = '/storage/writer/v1/nominal/{dataSourceRid}'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'POST',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            data=_data)
+
+        return
+
 
 storage_writer_api_NominalChannelWriterService.__name__ = "NominalChannelWriterService"
 storage_writer_api_NominalChannelWriterService.__qualname__ = "NominalChannelWriterService"

nominal_api/scout_chartdefinition_api/__init__.py

@@ -18,6 +18,7 @@ from .._impl import (
     scout_chartdefinition_api_ChecklistChartDefinitionVisitor as ChecklistChartDefinitionVisitor,
     scout_chartdefinition_api_DataSourceRefName as DataSourceRefName,
     scout_chartdefinition_api_DefaultFill as DefaultFill,
+    scout_chartdefinition_api_EnumCellConfig as EnumCellConfig,
     scout_chartdefinition_api_EnumRawVisualisation as EnumRawVisualisation,
     scout_chartdefinition_api_EnumValueChannel as EnumValueChannel,
     scout_chartdefinition_api_EnumValueVisualisation as EnumValueVisualisation,
@@ -51,15 +52,24 @@ from .._impl import (
     scout_chartdefinition_api_LineStyleVisitor as LineStyleVisitor,
     scout_chartdefinition_api_LineThreshold as LineThreshold,
     scout_chartdefinition_api_LineThresholdGroup as LineThresholdGroup,
+    scout_chartdefinition_api_NumberFormat as NumberFormat,
+    scout_chartdefinition_api_NumberFormatDisplayOption as NumberFormatDisplayOption,
     scout_chartdefinition_api_NumericBarGaugeVisualisation as NumericBarGaugeVisualisation,
+    scout_chartdefinition_api_NumericBarVisualisationV2 as NumericBarVisualisationV2,
+    scout_chartdefinition_api_NumericCellConfig as NumericCellConfig,
     scout_chartdefinition_api_NumericRawVisualisation as NumericRawVisualisation,
+    scout_chartdefinition_api_NumericRawVisualisationV2 as NumericRawVisualisationV2,
     scout_chartdefinition_api_NumericValueChannel as NumericValueChannel,
     scout_chartdefinition_api_NumericValueVisualisation as NumericValueVisualisation,
+    scout_chartdefinition_api_NumericValueVisualisationV2 as NumericValueVisualisationV2,
+    scout_chartdefinition_api_NumericValueVisualisationV2Visitor as NumericValueVisualisationV2Visitor,
     scout_chartdefinition_api_NumericValueVisualisationVisitor as NumericValueVisualisationVisitor,
+    scout_chartdefinition_api_RangeCellConfig as RangeCellConfig,
     scout_chartdefinition_api_RangeRawVisualisation as RangeRawVisualisation,
     scout_chartdefinition_api_RangeValueChannel as RangeValueChannel,
     scout_chartdefinition_api_RangeValueVisualisation as RangeValueVisualisation,
     scout_chartdefinition_api_RangeValueVisualisationVisitor as RangeValueVisualisationVisitor,
+    scout_chartdefinition_api_Threshold as Threshold,
     scout_chartdefinition_api_ThresholdLineStyle as ThresholdLineStyle,
     scout_chartdefinition_api_ThresholdShadingConfig as ThresholdShadingConfig,
     scout_chartdefinition_api_TimeSeriesChartDefinition as TimeSeriesChartDefinition,
@@ -68,11 +78,21 @@ from .._impl import (
     scout_chartdefinition_api_TimeSeriesPlot as TimeSeriesPlot,
     scout_chartdefinition_api_TimeSeriesRow as TimeSeriesRow,
     scout_chartdefinition_api_ValueAxis as ValueAxis,
+    scout_chartdefinition_api_ValueTableCell as ValueTableCell,
+    scout_chartdefinition_api_ValueTableCellConfig as ValueTableCellConfig,
+    scout_chartdefinition_api_ValueTableCellConfigVisitor as ValueTableCellConfigVisitor,
     scout_chartdefinition_api_ValueTableChannel as ValueTableChannel,
     scout_chartdefinition_api_ValueTableChannelVisitor as ValueTableChannelVisitor,
     scout_chartdefinition_api_ValueTableDefinition as ValueTableDefinition,
     scout_chartdefinition_api_ValueTableDefinitionV1 as ValueTableDefinitionV1,
+    scout_chartdefinition_api_ValueTableDefinitionV2 as ValueTableDefinitionV2,
     scout_chartdefinition_api_ValueTableDefinitionVisitor as ValueTableDefinitionVisitor,
+    scout_chartdefinition_api_ValueTableGridRowColumnConfig as ValueTableGridRowColumnConfig,
+    scout_chartdefinition_api_ValueTableGridValueTableCell as ValueTableGridValueTableCell,
+    scout_chartdefinition_api_ValueTableLayout as ValueTableLayout,
+    scout_chartdefinition_api_ValueTableLayoutGrid as ValueTableLayoutGrid,
+    scout_chartdefinition_api_ValueTableLayoutVisitor as ValueTableLayoutVisitor,
+    scout_chartdefinition_api_ValueTableMultiCellConfig as ValueTableMultiCellConfig,
     scout_chartdefinition_api_ValueToColorMap as ValueToColorMap,
     scout_chartdefinition_api_ValueToColorMapVisitor as ValueToColorMapVisitor,
     scout_chartdefinition_api_VideoVizDefinition as VideoVizDefinition,

{nominal_api-0.534.0.dist-info → nominal_api-0.536.0.dist-info}/METADATA

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

{nominal_api-0.534.0.dist-info → nominal_api-0.536.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
-nominal_api/__init__.py,sha256=TJotoxqxoRiTf1SYxVZtbh1iDFVJ4wKb7VpFZ0a_UU8,1762
-nominal_api/_impl.py,sha256=PjmngNYc3chuQgy0Wn58e7l9Prj8Izr17eHP2GnTP_o,2611978
+nominal_api/__init__.py,sha256=iiyOgpV6hfKJSPMJmSLWer-bZp7smOATaGtzO0OMf1A,1762
+nominal_api/_impl.py,sha256=1SeMLd_gAHaGHnrOgYCW5L1kwKiV2qIEYSvcuzznOjU,2643967
 nominal_api/py.typed,sha256=eoZ6GfifbqhMLNzjlqRDVil-yyBkOmVN9ujSgJWNBlY,15
 nominal_api/api/__init__.py,sha256=CaUmWhW0zcP8jVWFQEgj-lpoBi-Unm0wBd2s9dPeWmo,656
 nominal_api/api_rids/__init__.py,sha256=p7dKiMV692oGtYStr5FZJEJNg3YbF7scJK1WFMpBiW0,298
@@ -23,7 +23,7 @@ nominal_api/scout_backend/__init__.py,sha256=mQSE-783yT5X8adDwdg_IXwMONokeS3ohwT
 nominal_api/scout_catalog/__init__.py,sha256=06VquR4NsvOAmQQEpla8QJr7WN2Ky2j3tQgEVvEXZTA,3820
 nominal_api/scout_channelvariables_api/__init__.py,sha256=4OQV1O-M2MQE36yCGlyYftnqaXSddYTYTyGce_WC4JQ,466
 nominal_api/scout_chart_api/__init__.py,sha256=sw7WSYs6SarSW7x-3IBkSIrVea1cVFnQnpYiNKbCWnQ,184
-nominal_api/scout_chartdefinition_api/__init__.py,sha256=dhnhf06Gv7iNhf8wi-l1OsikCb8pFxwIwY9Fqs5m9gA,6294
+nominal_api/scout_chartdefinition_api/__init__.py,sha256=AMcVS4wUdI5rHxWNtG7k4Ex6-Sn3nf95F2Qn6ZTKWaE,7868
 nominal_api/scout_checklistexecution_api/__init__.py,sha256=PfMFzie0xO5d5WSpB3bE4yiRi2TQTjKn6jG5dlgU6F8,2472
 nominal_api/scout_checks_api/__init__.py,sha256=RJH7HsXjUhItC11V9C-hfv6lkIfiSXyxnB8slUpaT2g,5203
 nominal_api/scout_comparisonnotebook_api/__init__.py,sha256=8BL5jE9NDxqCj9DyvZWSPhq6zw2J7xp6aLsl3x9rpyw,4530
@@ -65,7 +65,7 @@ nominal_api/timeseries_logicalseries_api/__init__.py,sha256=wr83ByQTVVPOGvbB_KWL
 nominal_api/timeseries_seriescache/__init__.py,sha256=tFCkNuyrVMgtj-HIl1pOYPJHaL2VikI4C_x97bX_Lcs,109
 nominal_api/timeseries_seriescache_api/__init__.py,sha256=YLixotb-W-adYR6t_RBsJDwoHttppkOBesoaXERwhVs,1240
 nominal_api/upload_api/__init__.py,sha256=ZMudWMSqCrNozohbHaJKuxJnT9Edepe7nxxXMz_pT9k,87
-nominal_api-0.534.0.dist-info/METADATA,sha256=faZ_HbRO68uHWIvxQUDiofs7aeXbEDgPZlf2t8hINC4,199
-nominal_api-0.534.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-nominal_api-0.534.0.dist-info/top_level.txt,sha256=gI1ZdNJbuHcJZeKtCzzBXsEtpU1GX6XJKs6ksi_gCRA,12
-nominal_api-0.534.0.dist-info/RECORD,,
+nominal_api-0.536.0.dist-info/METADATA,sha256=-dX0UkYrmkP2g2imb0IRHz7THfiMohhgEsTok34pH38,199
+nominal_api-0.536.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+nominal_api-0.536.0.dist-info/top_level.txt,sha256=gI1ZdNJbuHcJZeKtCzzBXsEtpU1GX6XJKs6ksi_gCRA,12
+nominal_api-0.536.0.dist-info/RECORD,,