nominal-api 0.533.0__py3-none-any.whl → 0.535.0__py3-none-any.whl

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,23 +5198,22 @@ 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),
             'type': ConjureFieldDefinition('type', event_EventType),
             '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)
+            'is_archived': ConjureFieldDefinition('isArchived', bool),
+            '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']
+    __slots__: List[str] = ['_uuid', '_asset_rids', '_origins', '_timestamp', '_duration', '_name', '_type', '_labels', '_properties', '_is_archived', '_created_by']
 
-    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, 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
@@ -5234,6 +5221,7 @@ class event_Event(ConjureBeanType):
         self._labels = labels
         self._properties = properties
         self._is_archived = is_archived
+        self._created_by = created_by
 
     @builtins.property
     def uuid(self) -> str:
@@ -5253,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
@@ -5289,6 +5269,14 @@ Can be a workbook rid, asset rid, etc.
     def is_archived(self) -> bool:
         return self._is_archived
 
+    @builtins.property
+    def created_by(self) -> Optional[str]:
+        """
+        The user who created the event.
+This field may be missing for legacy events.
+        """
+        return self._created_by
+
 
 event_Event.__name__ = "Event"
 event_Event.__qualname__ = "Event"
@@ -5536,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.
         """
@@ -5553,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)
@@ -5985,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]),
@@ -5994,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
@@ -6019,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
@@ -10953,6 +10935,36 @@ Throws if the template, branch, or commit doesn't exist.
         _decoder = ConjureDecoder()
         return _decoder.decode(_response.json(), scout_template_api_Template, self._return_none_for_unknown_union_types)
 
+    def batch_get_metadata(self, auth_header: str, rids: List[str] = None) -> List["scout_template_api_TemplateSummary"]:
+        rids = rids if rids is not None else []
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+        }
+
+        _json: Any = ConjureEncoder().default(rids)
+
+        _path = '/scout/v1/template/batch-get-metadata'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'POST',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        _decoder = ConjureDecoder()
+        return _decoder.decode(_response.json(), List[scout_template_api_TemplateSummary], self._return_none_for_unknown_union_types)
+
     def save_working_state(self, auth_header: str, request: "scout_template_api_SaveTemplateRequest", template_rid: str, branch: Optional[str] = None) -> "scout_template_api_Template":
         """
         Creates a commit that may be compacted, e.g cleaned up and not exist anymore.
@@ -17450,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.
@@ -18525,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.
@@ -18557,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
@@ -18573,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
@@ -18679,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.
@@ -18796,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'
@@ -19090,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
@@ -19190,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"
@@ -19238,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"
@@ -19277,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
@@ -63020,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"
@@ -64357,35 +65215,6 @@ timeseries_archetype_api_CreateSeriesArchetypeRequest.__qualname__ = "CreateSeri
 timeseries_archetype_api_CreateSeriesArchetypeRequest.__module__ = "nominal_api.timeseries_archetype_api"
 
 
-class timeseries_archetype_api_CsvV3LocatorTemplate(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'channel': ConjureFieldDefinition('channel', api_Channel),
-            'type': ConjureFieldDefinition('type', timeseries_logicalseries_api_NominalType)
-        }
-
-    __slots__: List[str] = ['_channel', '_type']
-
-    def __init__(self, channel: str, type: "timeseries_logicalseries_api_NominalType") -> None:
-        self._channel = channel
-        self._type = type
-
-    @builtins.property
-    def channel(self) -> str:
-        return self._channel
-
-    @builtins.property
-    def type(self) -> "timeseries_logicalseries_api_NominalType":
-        return self._type
-
-
-timeseries_archetype_api_CsvV3LocatorTemplate.__name__ = "CsvV3LocatorTemplate"
-timeseries_archetype_api_CsvV3LocatorTemplate.__qualname__ = "CsvV3LocatorTemplate"
-timeseries_archetype_api_CsvV3LocatorTemplate.__module__ = "nominal_api.timeseries_archetype_api"
-
-
 class timeseries_archetype_api_Influx1LocatorTemplate(ConjureBeanType):
 
     @builtins.classmethod
@@ -64485,7 +65314,6 @@ class timeseries_archetype_api_LocatorTemplate(ConjureUnionType):
     _timestream: Optional["timeseries_archetype_api_TimestreamLocatorTemplate"] = None
     _visual_crossing: Optional["timeseries_archetype_api_VisualCrossingLocatorTemplate"] = None
     _big_query: Optional["timeseries_archetype_api_BigQueryLocatorTemplate"] = None
-    _csv_v3: Optional["timeseries_archetype_api_CsvV3LocatorTemplate"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
@@ -64496,8 +65324,7 @@ class timeseries_archetype_api_LocatorTemplate(ConjureUnionType):
             'nominal': ConjureFieldDefinition('nominal', timeseries_archetype_api_NominalLocatorTemplate),
             'timestream': ConjureFieldDefinition('timestream', timeseries_archetype_api_TimestreamLocatorTemplate),
             'visual_crossing': ConjureFieldDefinition('visualCrossing', timeseries_archetype_api_VisualCrossingLocatorTemplate),
-            'big_query': ConjureFieldDefinition('bigQuery', timeseries_archetype_api_BigQueryLocatorTemplate),
-            'csv_v3': ConjureFieldDefinition('csvV3', timeseries_archetype_api_CsvV3LocatorTemplate)
+            'big_query': ConjureFieldDefinition('bigQuery', timeseries_archetype_api_BigQueryLocatorTemplate)
         }
 
     def __init__(
@@ -64509,11 +65336,10 @@ class timeseries_archetype_api_LocatorTemplate(ConjureUnionType):
             timestream: Optional["timeseries_archetype_api_TimestreamLocatorTemplate"] = None,
             visual_crossing: Optional["timeseries_archetype_api_VisualCrossingLocatorTemplate"] = None,
             big_query: Optional["timeseries_archetype_api_BigQueryLocatorTemplate"] = None,
-            csv_v3: Optional["timeseries_archetype_api_CsvV3LocatorTemplate"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (timescale_db is not None) + (influx is not None) + (influx1 is not None) + (nominal is not None) + (timestream is not None) + (visual_crossing is not None) + (big_query is not None) + (csv_v3 is not None) != 1:
+            if (timescale_db is not None) + (influx is not None) + (influx1 is not None) + (nominal is not None) + (timestream is not None) + (visual_crossing is not None) + (big_query is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if timescale_db is not None:
@@ -64537,9 +65363,6 @@ class timeseries_archetype_api_LocatorTemplate(ConjureUnionType):
             if big_query is not None:
                 self._big_query = big_query
                 self._type = 'bigQuery'
-            if csv_v3 is not None:
-                self._csv_v3 = csv_v3
-                self._type = 'csvV3'
 
         elif type_of_union == 'timescaleDb':
             if timescale_db is None:
@@ -64576,11 +65399,6 @@ class timeseries_archetype_api_LocatorTemplate(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._big_query = big_query
             self._type = 'bigQuery'
-        elif type_of_union == 'csvV3':
-            if csv_v3 is None:
-                raise ValueError('a union value must not be None')
-            self._csv_v3 = csv_v3
-            self._type = 'csvV3'
 
     @builtins.property
     def timescale_db(self) -> Optional["timeseries_archetype_api_TimescaleDbLocatorTemplate"]:
@@ -64610,10 +65428,6 @@ class timeseries_archetype_api_LocatorTemplate(ConjureUnionType):
     def big_query(self) -> Optional["timeseries_archetype_api_BigQueryLocatorTemplate"]:
         return self._big_query
 
-    @builtins.property
-    def csv_v3(self) -> Optional["timeseries_archetype_api_CsvV3LocatorTemplate"]:
-        return self._csv_v3
-
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, timeseries_archetype_api_LocatorTemplateVisitor):
             raise ValueError('{} is not an instance of timeseries_archetype_api_LocatorTemplateVisitor'.format(visitor.__class__.__name__))
@@ -64631,8 +65445,6 @@ class timeseries_archetype_api_LocatorTemplate(ConjureUnionType):
             return visitor._visual_crossing(self.visual_crossing)
         if self._type == 'bigQuery' and self.big_query is not None:
             return visitor._big_query(self.big_query)
-        if self._type == 'csvV3' and self.csv_v3 is not None:
-            return visitor._csv_v3(self.csv_v3)
 
 
 timeseries_archetype_api_LocatorTemplate.__name__ = "LocatorTemplate"
@@ -64670,10 +65482,6 @@ class timeseries_archetype_api_LocatorTemplateVisitor:
     def _big_query(self, big_query: "timeseries_archetype_api_BigQueryLocatorTemplate") -> Any:
         pass
 
-    @abstractmethod
-    def _csv_v3(self, csv_v3: "timeseries_archetype_api_CsvV3LocatorTemplate") -> Any:
-        pass
-
 
 timeseries_archetype_api_LocatorTemplateVisitor.__name__ = "LocatorTemplateVisitor"
 timeseries_archetype_api_LocatorTemplateVisitor.__qualname__ = "LocatorTemplateVisitor"
@@ -65579,41 +66387,6 @@ timeseries_logicalseries_api_CsvLocatorV2.__qualname__ = "CsvLocatorV2"
 timeseries_logicalseries_api_CsvLocatorV2.__module__ = "nominal_api.timeseries_logicalseries_api"
 
 
-class timeseries_logicalseries_api_CsvLocatorV3(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'channel': ConjureFieldDefinition('channel', api_Channel),
-            'type': ConjureFieldDefinition('type', timeseries_logicalseries_api_NominalType),
-            'tags': ConjureFieldDefinition('tags', Dict[api_TagName, api_TagValue])
-        }
-
-    __slots__: List[str] = ['_channel', '_type', '_tags']
-
-    def __init__(self, channel: str, tags: Dict[str, str], type: "timeseries_logicalseries_api_NominalType") -> None:
-        self._channel = channel
-        self._type = type
-        self._tags = tags
-
-    @builtins.property
-    def channel(self) -> str:
-        return self._channel
-
-    @builtins.property
-    def type(self) -> "timeseries_logicalseries_api_NominalType":
-        return self._type
-
-    @builtins.property
-    def tags(self) -> Dict[str, str]:
-        return self._tags
-
-
-timeseries_logicalseries_api_CsvLocatorV3.__name__ = "CsvLocatorV3"
-timeseries_logicalseries_api_CsvLocatorV3.__qualname__ = "CsvLocatorV3"
-timeseries_logicalseries_api_CsvLocatorV3.__module__ = "nominal_api.timeseries_logicalseries_api"
-
-
 class timeseries_logicalseries_api_Empty(ConjureBeanType):
 
     @builtins.classmethod
@@ -65820,7 +66593,6 @@ timeseries_logicalseries_api_InfluxType.__module__ = "nominal_api.timeseries_log
 class timeseries_logicalseries_api_Locator(ConjureUnionType):
     _csv_locator: Optional["timeseries_logicalseries_api_CsvLocator"] = None
     _csv_v2: Optional["timeseries_logicalseries_api_CsvLocatorV2"] = None
-    _csv_v3: Optional["timeseries_logicalseries_api_CsvLocatorV3"] = None
     _timescale_db_locator: Optional["timeseries_logicalseries_api_TimescaleDbLocator"] = None
     _influx_locator: Optional["timeseries_logicalseries_api_Influx2Locator"] = None
     _influx1_locator: Optional["timeseries_logicalseries_api_Influx1Locator"] = None
@@ -65834,7 +66606,6 @@ class timeseries_logicalseries_api_Locator(ConjureUnionType):
         return {
             'csv_locator': ConjureFieldDefinition('csvLocator', timeseries_logicalseries_api_CsvLocator),
             'csv_v2': ConjureFieldDefinition('csvV2', timeseries_logicalseries_api_CsvLocatorV2),
-            'csv_v3': ConjureFieldDefinition('csvV3', timeseries_logicalseries_api_CsvLocatorV3),
             'timescale_db_locator': ConjureFieldDefinition('timescaleDbLocator', timeseries_logicalseries_api_TimescaleDbLocator),
             'influx_locator': ConjureFieldDefinition('influxLocator', timeseries_logicalseries_api_Influx2Locator),
             'influx1_locator': ConjureFieldDefinition('influx1Locator', timeseries_logicalseries_api_Influx1Locator),
@@ -65848,7 +66619,6 @@ class timeseries_logicalseries_api_Locator(ConjureUnionType):
             self,
             csv_locator: Optional["timeseries_logicalseries_api_CsvLocator"] = None,
             csv_v2: Optional["timeseries_logicalseries_api_CsvLocatorV2"] = None,
-            csv_v3: Optional["timeseries_logicalseries_api_CsvLocatorV3"] = None,
             timescale_db_locator: Optional["timeseries_logicalseries_api_TimescaleDbLocator"] = None,
             influx_locator: Optional["timeseries_logicalseries_api_Influx2Locator"] = None,
             influx1_locator: Optional["timeseries_logicalseries_api_Influx1Locator"] = None,
@@ -65859,7 +66629,7 @@ class timeseries_logicalseries_api_Locator(ConjureUnionType):
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (csv_locator is not None) + (csv_v2 is not None) + (csv_v3 is not None) + (timescale_db_locator is not None) + (influx_locator is not None) + (influx1_locator is not None) + (nominal_locator is not None) + (timestream_locator is not None) + (visual_crossing_locator is not None) + (big_query_locator is not None) != 1:
+            if (csv_locator is not None) + (csv_v2 is not None) + (timescale_db_locator is not None) + (influx_locator is not None) + (influx1_locator is not None) + (nominal_locator is not None) + (timestream_locator is not None) + (visual_crossing_locator is not None) + (big_query_locator is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if csv_locator is not None:
@@ -65868,9 +66638,6 @@ class timeseries_logicalseries_api_Locator(ConjureUnionType):
             if csv_v2 is not None:
                 self._csv_v2 = csv_v2
                 self._type = 'csvV2'
-            if csv_v3 is not None:
-                self._csv_v3 = csv_v3
-                self._type = 'csvV3'
             if timescale_db_locator is not None:
                 self._timescale_db_locator = timescale_db_locator
                 self._type = 'timescaleDbLocator'
@@ -65903,11 +66670,6 @@ class timeseries_logicalseries_api_Locator(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._csv_v2 = csv_v2
             self._type = 'csvV2'
-        elif type_of_union == 'csvV3':
-            if csv_v3 is None:
-                raise ValueError('a union value must not be None')
-            self._csv_v3 = csv_v3
-            self._type = 'csvV3'
         elif type_of_union == 'timescaleDbLocator':
             if timescale_db_locator is None:
                 raise ValueError('a union value must not be None')
@@ -65952,10 +66714,6 @@ class timeseries_logicalseries_api_Locator(ConjureUnionType):
     def csv_v2(self) -> Optional["timeseries_logicalseries_api_CsvLocatorV2"]:
         return self._csv_v2
 
-    @builtins.property
-    def csv_v3(self) -> Optional["timeseries_logicalseries_api_CsvLocatorV3"]:
-        return self._csv_v3
-
     @builtins.property
     def timescale_db_locator(self) -> Optional["timeseries_logicalseries_api_TimescaleDbLocator"]:
         return self._timescale_db_locator
@@ -65991,8 +66749,6 @@ class timeseries_logicalseries_api_Locator(ConjureUnionType):
             return visitor._csv_locator(self.csv_locator)
         if self._type == 'csvV2' and self.csv_v2 is not None:
             return visitor._csv_v2(self.csv_v2)
-        if self._type == 'csvV3' and self.csv_v3 is not None:
-            return visitor._csv_v3(self.csv_v3)
         if self._type == 'timescaleDbLocator' and self.timescale_db_locator is not None:
             return visitor._timescale_db_locator(self.timescale_db_locator)
         if self._type == 'influxLocator' and self.influx_locator is not None:
@@ -66024,10 +66780,6 @@ class timeseries_logicalseries_api_LocatorVisitor:
     def _csv_v2(self, csv_v2: "timeseries_logicalseries_api_CsvLocatorV2") -> Any:
         pass
 
-    @abstractmethod
-    def _csv_v3(self, csv_v3: "timeseries_logicalseries_api_CsvLocatorV3") -> Any:
-        pass
-
     @abstractmethod
     def _timescale_db_locator(self, timescale_db_locator: "timeseries_logicalseries_api_TimescaleDbLocator") -> Any:
         pass