nominal-api 0.648.0__py3-none-any.whl → 0.649.1__py3-none-any.whl

nominal_api/_impl.py

@@ -445,16 +445,18 @@ results to clients as part of a response object when directly throwing an except
             'name': ConjureFieldDefinition('name', str),
             'message': ConjureFieldDefinition('message', OptionalTypeWrapper[str]),
             'error_instance_id': ConjureFieldDefinition('errorInstanceId', str),
-            'status_code': ConjureFieldDefinition('statusCode', int)
+            'status_code': ConjureFieldDefinition('statusCode', int),
+            'params': ConjureFieldDefinition('params', Dict[str, str])
         }
 
-    __slots__: List[str] = ['_name', '_message', '_error_instance_id', '_status_code']
+    __slots__: List[str] = ['_name', '_message', '_error_instance_id', '_status_code', '_params']
 
-    def __init__(self, error_instance_id: str, name: str, status_code: int, message: Optional[str] = None) -> None:
+    def __init__(self, error_instance_id: str, name: str, params: Dict[str, str], status_code: int, message: Optional[str] = None) -> None:
         self._name = name
         self._message = message
         self._error_instance_id = error_instance_id
         self._status_code = status_code
+        self._params = params
 
     @builtins.property
     def name(self) -> str:
@@ -472,6 +474,10 @@ results to clients as part of a response object when directly throwing an except
     def status_code(self) -> int:
         return self._status_code
 
+    @builtins.property
+    def params(self) -> Dict[str, str]:
+        return self._params
+
 
 api_SerializableError.__name__ = "SerializableError"
 api_SerializableError.__qualname__ = "SerializableError"
@@ -13672,6 +13678,71 @@ a RunNotFound error will be thrown.
         _decoder = ConjureDecoder()
         return _decoder.decode(_response.json(), scout_notebook_api_NotebookMetadata, self._return_none_for_unknown_union_types)
 
+    def get_used_ref_names(self, auth_header: str, rid: str) -> List[str]:
+        """
+        Returns the set of all ref names used by the workbook.
+        """
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+            'rid': rid,
+        }
+
+        _json: Any = None
+
+        _path = '/scout/v2/notebook/{rid}/ref-names'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'GET',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        _decoder = ConjureDecoder()
+        return _decoder.decode(_response.json(), List[scout_api_DataSourceRefName], self._return_none_for_unknown_union_types)
+
+    def update_ref_names(self, auth_header: str, request: "scout_notebook_api_UpdateRefNameRequest", rid: str) -> "scout_notebook_api_Notebook":
+        """
+        Updates the data source ref names for all variables used in the workbook.
+        """
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+            'rid': rid,
+        }
+
+        _json: Any = ConjureEncoder().default(request)
+
+        _path = '/scout/v2/notebook/{rid}/update-ref-names'
+        _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(), scout_notebook_api_Notebook, self._return_none_for_unknown_union_types)
+
     def get_all_labels_and_properties(self, auth_header: str, workspaces: List[str] = None) -> "scout_notebook_api_GetAllLabelsAndPropertiesResponse":
         """
         Returns all properties (key value pairs) and labels that have been previously used on workbook. These can
@@ -14665,6 +14736,74 @@ Throws if you save to an archived template.
         _decoder = ConjureDecoder()
         return _decoder.decode(_response.json(), scout_template_api_Template, self._return_none_for_unknown_union_types)
 
+    def get_used_ref_names(self, auth_header: str, template_rid: str, branch: Optional[str] = None, commit: Optional[str] = None) -> List[str]:
+        """
+        Returns the set of all ref names used by the template.
+        """
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+            'branch': branch,
+            'commit': commit,
+        }
+
+        _path_params: Dict[str, Any] = {
+            'templateRid': template_rid,
+        }
+
+        _json: Any = None
+
+        _path = '/scout/v1/template/{templateRid}/ref-names'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'GET',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        _decoder = ConjureDecoder()
+        return _decoder.decode(_response.json(), List[scout_api_DataSourceRefName], self._return_none_for_unknown_union_types)
+
+    def update_ref_names(self, auth_header: str, request: "scout_template_api_UpdateRefNameRequest", template_rid: str, branch: Optional[str] = None) -> "scout_template_api_Template":
+        """
+        Updates the data source ref names for all variables used in the template.
+        """
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+            'branch': branch,
+        }
+
+        _path_params: Dict[str, Any] = {
+            'templateRid': template_rid,
+        }
+
+        _json: Any = ConjureEncoder().default(request)
+
+        _path = '/scout/v1/template/{templateRid}/update-ref-names'
+        _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(), scout_template_api_Template, self._return_none_for_unknown_union_types)
+
     def commit(self, auth_header: str, request: "scout_template_api_CommitTemplateRequest", template_rid: str, branch: Optional[str] = None) -> "scout_template_api_Template":
         """
         Creates a commit with a commit message. 
@@ -34319,21 +34458,21 @@ scout_compute_api_ComputeNodeRequest.__module__ = "nominal_api.scout_compute_api
 
 
 class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
-    _numeric: Optional["scout_compute_api_NumericPlot"] = None
-    _bucketed_numeric: Optional["scout_compute_api_BucketedNumericPlot"] = None
     _range: Optional[List["scout_compute_api_Range"]] = None
     _ranges_summary: Optional["scout_compute_api_RangesSummary"] = None
+    _range_value: Optional[Optional["scout_compute_api_Range"]] = None
+    _numeric: Optional["scout_compute_api_NumericPlot"] = None
+    _bucketed_numeric: Optional["scout_compute_api_BucketedNumericPlot"] = None
+    _numeric_point: Optional[Optional["scout_compute_api_NumericPoint"]] = None
     _enum: Optional["scout_compute_api_EnumPlot"] = None
-    _paged_log: Optional["scout_compute_api_PagedLogPlot"] = None
+    _enum_point: Optional[Optional["scout_compute_api_EnumPoint"]] = None
     _bucketed_enum: Optional["scout_compute_api_BucketedEnumPlot"] = None
+    _paged_log: Optional["scout_compute_api_PagedLogPlot"] = None
+    _log_point: Optional[Optional["scout_compute_api_LogPoint"]] = None
     _cartesian: Optional["scout_compute_api_CartesianPlot"] = None
     _bucketed_cartesian: Optional["scout_compute_api_BucketedCartesianPlot"] = None
     _bucketed_cartesian3d: Optional["scout_compute_api_BucketedCartesian3dPlot"] = None
     _bucketed_geo: Optional["scout_compute_api_BucketedGeoPlot"] = None
-    _enum_point: Optional[Optional["scout_compute_api_EnumPoint"]] = None
-    _numeric_point: Optional[Optional["scout_compute_api_NumericPoint"]] = None
-    _log_point: Optional[Optional["scout_compute_api_LogPoint"]] = None
-    _range_value: Optional[Optional["scout_compute_api_Range"]] = None
     _frequency_domain: Optional["scout_compute_api_FrequencyDomainPlot"] = None
     _numeric_histogram: Optional["scout_compute_api_NumericHistogramPlot"] = None
     _enum_histogram: Optional["scout_compute_api_EnumHistogramPlot"] = None
@@ -34342,21 +34481,21 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'numeric': ConjureFieldDefinition('numeric', scout_compute_api_NumericPlot),
-            'bucketed_numeric': ConjureFieldDefinition('bucketedNumeric', scout_compute_api_BucketedNumericPlot),
             'range': ConjureFieldDefinition('range', List[scout_compute_api_Range]),
             'ranges_summary': ConjureFieldDefinition('rangesSummary', scout_compute_api_RangesSummary),
+            'range_value': ConjureFieldDefinition('rangeValue', OptionalTypeWrapper[scout_compute_api_Range]),
+            'numeric': ConjureFieldDefinition('numeric', scout_compute_api_NumericPlot),
+            'bucketed_numeric': ConjureFieldDefinition('bucketedNumeric', scout_compute_api_BucketedNumericPlot),
+            'numeric_point': ConjureFieldDefinition('numericPoint', OptionalTypeWrapper[scout_compute_api_NumericPoint]),
             'enum': ConjureFieldDefinition('enum', scout_compute_api_EnumPlot),
-            'paged_log': ConjureFieldDefinition('pagedLog', scout_compute_api_PagedLogPlot),
+            'enum_point': ConjureFieldDefinition('enumPoint', OptionalTypeWrapper[scout_compute_api_EnumPoint]),
             'bucketed_enum': ConjureFieldDefinition('bucketedEnum', scout_compute_api_BucketedEnumPlot),
+            'paged_log': ConjureFieldDefinition('pagedLog', scout_compute_api_PagedLogPlot),
+            'log_point': ConjureFieldDefinition('logPoint', OptionalTypeWrapper[scout_compute_api_LogPoint]),
             'cartesian': ConjureFieldDefinition('cartesian', scout_compute_api_CartesianPlot),
             'bucketed_cartesian': ConjureFieldDefinition('bucketedCartesian', scout_compute_api_BucketedCartesianPlot),
             'bucketed_cartesian3d': ConjureFieldDefinition('bucketedCartesian3d', scout_compute_api_BucketedCartesian3dPlot),
             'bucketed_geo': ConjureFieldDefinition('bucketedGeo', scout_compute_api_BucketedGeoPlot),
-            'enum_point': ConjureFieldDefinition('enumPoint', OptionalTypeWrapper[scout_compute_api_EnumPoint]),
-            'numeric_point': ConjureFieldDefinition('numericPoint', OptionalTypeWrapper[scout_compute_api_NumericPoint]),
-            'log_point': ConjureFieldDefinition('logPoint', OptionalTypeWrapper[scout_compute_api_LogPoint]),
-            'range_value': ConjureFieldDefinition('rangeValue', OptionalTypeWrapper[scout_compute_api_Range]),
             'frequency_domain': ConjureFieldDefinition('frequencyDomain', scout_compute_api_FrequencyDomainPlot),
             'numeric_histogram': ConjureFieldDefinition('numericHistogram', scout_compute_api_NumericHistogramPlot),
             'enum_histogram': ConjureFieldDefinition('enumHistogram', scout_compute_api_EnumHistogramPlot),
@@ -34365,21 +34504,21 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
 
     def __init__(
             self,
-            numeric: Optional["scout_compute_api_NumericPlot"] = None,
-            bucketed_numeric: Optional["scout_compute_api_BucketedNumericPlot"] = None,
             range: Optional[List["scout_compute_api_Range"]] = None,
             ranges_summary: Optional["scout_compute_api_RangesSummary"] = None,
+            range_value: Optional[Optional["scout_compute_api_Range"]] = None,
+            numeric: Optional["scout_compute_api_NumericPlot"] = None,
+            bucketed_numeric: Optional["scout_compute_api_BucketedNumericPlot"] = None,
+            numeric_point: Optional[Optional["scout_compute_api_NumericPoint"]] = None,
             enum: Optional["scout_compute_api_EnumPlot"] = None,
-            paged_log: Optional["scout_compute_api_PagedLogPlot"] = None,
+            enum_point: Optional[Optional["scout_compute_api_EnumPoint"]] = None,
             bucketed_enum: Optional["scout_compute_api_BucketedEnumPlot"] = None,
+            paged_log: Optional["scout_compute_api_PagedLogPlot"] = None,
+            log_point: Optional[Optional["scout_compute_api_LogPoint"]] = None,
             cartesian: Optional["scout_compute_api_CartesianPlot"] = None,
             bucketed_cartesian: Optional["scout_compute_api_BucketedCartesianPlot"] = None,
             bucketed_cartesian3d: Optional["scout_compute_api_BucketedCartesian3dPlot"] = None,
             bucketed_geo: Optional["scout_compute_api_BucketedGeoPlot"] = None,
-            enum_point: Optional[Optional["scout_compute_api_EnumPoint"]] = None,
-            numeric_point: Optional[Optional["scout_compute_api_NumericPoint"]] = None,
-            log_point: Optional[Optional["scout_compute_api_LogPoint"]] = None,
-            range_value: Optional[Optional["scout_compute_api_Range"]] = None,
             frequency_domain: Optional["scout_compute_api_FrequencyDomainPlot"] = None,
             numeric_histogram: Optional["scout_compute_api_NumericHistogramPlot"] = None,
             enum_histogram: Optional["scout_compute_api_EnumHistogramPlot"] = None,
@@ -34387,30 +34526,42 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (numeric is not None) + (bucketed_numeric is not None) + (range is not None) + (ranges_summary is not None) + (enum is not None) + (paged_log is not None) + (bucketed_enum is not None) + (cartesian is not None) + (bucketed_cartesian is not None) + (bucketed_cartesian3d is not None) + (bucketed_geo is not None) + (enum_point is not None) + (numeric_point is not None) + (log_point is not None) + (range_value is not None) + (frequency_domain is not None) + (numeric_histogram is not None) + (enum_histogram is not None) + (curve_fit is not None) != 1:
+            if (range is not None) + (ranges_summary is not None) + (range_value is not None) + (numeric is not None) + (bucketed_numeric is not None) + (numeric_point is not None) + (enum is not None) + (enum_point is not None) + (bucketed_enum is not None) + (paged_log is not None) + (log_point is not None) + (cartesian is not None) + (bucketed_cartesian is not None) + (bucketed_cartesian3d is not None) + (bucketed_geo is not None) + (frequency_domain is not None) + (numeric_histogram is not None) + (enum_histogram is not None) + (curve_fit 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 bucketed_numeric is not None:
-                self._bucketed_numeric = bucketed_numeric
-                self._type = 'bucketedNumeric'
             if range is not None:
                 self._range = range
                 self._type = 'range'
             if ranges_summary is not None:
                 self._ranges_summary = ranges_summary
                 self._type = 'rangesSummary'
+            if range_value is not None:
+                self._range_value = range_value
+                self._type = 'rangeValue'
+            if numeric is not None:
+                self._numeric = numeric
+                self._type = 'numeric'
+            if bucketed_numeric is not None:
+                self._bucketed_numeric = bucketed_numeric
+                self._type = 'bucketedNumeric'
+            if numeric_point is not None:
+                self._numeric_point = numeric_point
+                self._type = 'numericPoint'
             if enum is not None:
                 self._enum = enum
                 self._type = 'enum'
-            if paged_log is not None:
-                self._paged_log = paged_log
-                self._type = 'pagedLog'
+            if enum_point is not None:
+                self._enum_point = enum_point
+                self._type = 'enumPoint'
             if bucketed_enum is not None:
                 self._bucketed_enum = bucketed_enum
                 self._type = 'bucketedEnum'
+            if paged_log is not None:
+                self._paged_log = paged_log
+                self._type = 'pagedLog'
+            if log_point is not None:
+                self._log_point = log_point
+                self._type = 'logPoint'
             if cartesian is not None:
                 self._cartesian = cartesian
                 self._type = 'cartesian'
@@ -34423,18 +34574,6 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
             if bucketed_geo is not None:
                 self._bucketed_geo = bucketed_geo
                 self._type = 'bucketedGeo'
-            if enum_point is not None:
-                self._enum_point = enum_point
-                self._type = 'enumPoint'
-            if numeric_point is not None:
-                self._numeric_point = numeric_point
-                self._type = 'numericPoint'
-            if log_point is not None:
-                self._log_point = log_point
-                self._type = 'logPoint'
-            if range_value is not None:
-                self._range_value = range_value
-                self._type = 'rangeValue'
             if frequency_domain is not None:
                 self._frequency_domain = frequency_domain
                 self._type = 'frequencyDomain'
@@ -34448,6 +34587,21 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
                 self._curve_fit = curve_fit
                 self._type = 'curveFit'
 
+        elif type_of_union == 'range':
+            if range is None:
+                raise ValueError('a union value must not be None')
+            self._range = range
+            self._type = 'range'
+        elif type_of_union == 'rangesSummary':
+            if ranges_summary is None:
+                raise ValueError('a union value must not be None')
+            self._ranges_summary = ranges_summary
+            self._type = 'rangesSummary'
+        elif type_of_union == 'rangeValue':
+            if range_value is None:
+                raise ValueError('a union value must not be None')
+            self._range_value = range_value
+            self._type = 'rangeValue'
         elif type_of_union == 'numeric':
             if numeric is None:
                 raise ValueError('a union value must not be None')
@@ -34458,31 +34612,36 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._bucketed_numeric = bucketed_numeric
             self._type = 'bucketedNumeric'
-        elif type_of_union == 'range':
-            if range is None:
-                raise ValueError('a union value must not be None')
-            self._range = range
-            self._type = 'range'
-        elif type_of_union == 'rangesSummary':
-            if ranges_summary is None:
+        elif type_of_union == 'numericPoint':
+            if numeric_point is None:
                 raise ValueError('a union value must not be None')
-            self._ranges_summary = ranges_summary
-            self._type = 'rangesSummary'
+            self._numeric_point = numeric_point
+            self._type = 'numericPoint'
         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 == 'pagedLog':
-            if paged_log is None:
+        elif type_of_union == 'enumPoint':
+            if enum_point is None:
                 raise ValueError('a union value must not be None')
-            self._paged_log = paged_log
-            self._type = 'pagedLog'
+            self._enum_point = enum_point
+            self._type = 'enumPoint'
         elif type_of_union == 'bucketedEnum':
             if bucketed_enum is None:
                 raise ValueError('a union value must not be None')
             self._bucketed_enum = bucketed_enum
             self._type = 'bucketedEnum'
+        elif type_of_union == 'pagedLog':
+            if paged_log is None:
+                raise ValueError('a union value must not be None')
+            self._paged_log = paged_log
+            self._type = 'pagedLog'
+        elif type_of_union == 'logPoint':
+            if log_point is None:
+                raise ValueError('a union value must not be None')
+            self._log_point = log_point
+            self._type = 'logPoint'
         elif type_of_union == 'cartesian':
             if cartesian is None:
                 raise ValueError('a union value must not be None')
@@ -34503,26 +34662,6 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._bucketed_geo = bucketed_geo
             self._type = 'bucketedGeo'
-        elif type_of_union == 'enumPoint':
-            if enum_point is None:
-                raise ValueError('a union value must not be None')
-            self._enum_point = enum_point
-            self._type = 'enumPoint'
-        elif type_of_union == 'numericPoint':
-            if numeric_point is None:
-                raise ValueError('a union value must not be None')
-            self._numeric_point = numeric_point
-            self._type = 'numericPoint'
-        elif type_of_union == 'logPoint':
-            if log_point is None:
-                raise ValueError('a union value must not be None')
-            self._log_point = log_point
-            self._type = 'logPoint'
-        elif type_of_union == 'rangeValue':
-            if range_value is None:
-                raise ValueError('a union value must not be None')
-            self._range_value = range_value
-            self._type = 'rangeValue'
         elif type_of_union == 'frequencyDomain':
             if frequency_domain is None:
                 raise ValueError('a union value must not be None')
@@ -34544,6 +34683,18 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
             self._curve_fit = curve_fit
             self._type = 'curveFit'
 
+    @builtins.property
+    def range(self) -> Optional[List["scout_compute_api_Range"]]:
+        return self._range
+
+    @builtins.property
+    def ranges_summary(self) -> Optional["scout_compute_api_RangesSummary"]:
+        return self._ranges_summary
+
+    @builtins.property
+    def range_value(self) -> Optional[Optional["scout_compute_api_Range"]]:
+        return self._range_value
+
     @builtins.property
     def numeric(self) -> Optional["scout_compute_api_NumericPlot"]:
         return self._numeric
@@ -34553,25 +34704,29 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
         return self._bucketed_numeric
 
     @builtins.property
-    def range(self) -> Optional[List["scout_compute_api_Range"]]:
-        return self._range
-
-    @builtins.property
-    def ranges_summary(self) -> Optional["scout_compute_api_RangesSummary"]:
-        return self._ranges_summary
+    def numeric_point(self) -> Optional[Optional["scout_compute_api_NumericPoint"]]:
+        return self._numeric_point
 
     @builtins.property
     def enum(self) -> Optional["scout_compute_api_EnumPlot"]:
         return self._enum
 
     @builtins.property
-    def paged_log(self) -> Optional["scout_compute_api_PagedLogPlot"]:
-        return self._paged_log
+    def enum_point(self) -> Optional[Optional["scout_compute_api_EnumPoint"]]:
+        return self._enum_point
 
     @builtins.property
     def bucketed_enum(self) -> Optional["scout_compute_api_BucketedEnumPlot"]:
         return self._bucketed_enum
 
+    @builtins.property
+    def paged_log(self) -> Optional["scout_compute_api_PagedLogPlot"]:
+        return self._paged_log
+
+    @builtins.property
+    def log_point(self) -> Optional[Optional["scout_compute_api_LogPoint"]]:
+        return self._log_point
+
     @builtins.property
     def cartesian(self) -> Optional["scout_compute_api_CartesianPlot"]:
         return self._cartesian
@@ -34588,22 +34743,6 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
     def bucketed_geo(self) -> Optional["scout_compute_api_BucketedGeoPlot"]:
         return self._bucketed_geo
 
-    @builtins.property
-    def enum_point(self) -> Optional[Optional["scout_compute_api_EnumPoint"]]:
-        return self._enum_point
-
-    @builtins.property
-    def numeric_point(self) -> Optional[Optional["scout_compute_api_NumericPoint"]]:
-        return self._numeric_point
-
-    @builtins.property
-    def log_point(self) -> Optional[Optional["scout_compute_api_LogPoint"]]:
-        return self._log_point
-
-    @builtins.property
-    def range_value(self) -> Optional[Optional["scout_compute_api_Range"]]:
-        return self._range_value
-
     @builtins.property
     def frequency_domain(self) -> Optional["scout_compute_api_FrequencyDomainPlot"]:
         return self._frequency_domain
@@ -34623,20 +34762,28 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, scout_compute_api_ComputeNodeResponseVisitor):
             raise ValueError('{} is not an instance of scout_compute_api_ComputeNodeResponseVisitor'.format(visitor.__class__.__name__))
-        if self._type == 'numeric' and self.numeric is not None:
-            return visitor._numeric(self.numeric)
-        if self._type == 'bucketedNumeric' and self.bucketed_numeric is not None:
-            return visitor._bucketed_numeric(self.bucketed_numeric)
         if self._type == 'range' and self.range is not None:
             return visitor._range(self.range)
         if self._type == 'rangesSummary' and self.ranges_summary is not None:
             return visitor._ranges_summary(self.ranges_summary)
+        if self._type == 'rangeValue' and self.range_value is not None:
+            return visitor._range_value(self.range_value)
+        if self._type == 'numeric' and self.numeric is not None:
+            return visitor._numeric(self.numeric)
+        if self._type == 'bucketedNumeric' and self.bucketed_numeric is not None:
+            return visitor._bucketed_numeric(self.bucketed_numeric)
+        if self._type == 'numericPoint' and self.numeric_point is not None:
+            return visitor._numeric_point(self.numeric_point)
         if self._type == 'enum' and self.enum is not None:
             return visitor._enum(self.enum)
-        if self._type == 'pagedLog' and self.paged_log is not None:
-            return visitor._paged_log(self.paged_log)
+        if self._type == 'enumPoint' and self.enum_point is not None:
+            return visitor._enum_point(self.enum_point)
         if self._type == 'bucketedEnum' and self.bucketed_enum is not None:
             return visitor._bucketed_enum(self.bucketed_enum)
+        if self._type == 'pagedLog' and self.paged_log is not None:
+            return visitor._paged_log(self.paged_log)
+        if self._type == 'logPoint' and self.log_point is not None:
+            return visitor._log_point(self.log_point)
         if self._type == 'cartesian' and self.cartesian is not None:
             return visitor._cartesian(self.cartesian)
         if self._type == 'bucketedCartesian' and self.bucketed_cartesian is not None:
@@ -34645,14 +34792,6 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
             return visitor._bucketed_cartesian3d(self.bucketed_cartesian3d)
         if self._type == 'bucketedGeo' and self.bucketed_geo is not None:
             return visitor._bucketed_geo(self.bucketed_geo)
-        if self._type == 'enumPoint' and self.enum_point is not None:
-            return visitor._enum_point(self.enum_point)
-        if self._type == 'numericPoint' and self.numeric_point is not None:
-            return visitor._numeric_point(self.numeric_point)
-        if self._type == 'logPoint' and self.log_point is not None:
-            return visitor._log_point(self.log_point)
-        if self._type == 'rangeValue' and self.range_value is not None:
-            return visitor._range_value(self.range_value)
         if self._type == 'frequencyDomain' and self.frequency_domain is not None:
             return visitor._frequency_domain(self.frequency_domain)
         if self._type == 'numericHistogram' and self.numeric_histogram is not None:
@@ -34671,63 +34810,63 @@ scout_compute_api_ComputeNodeResponse.__module__ = "nominal_api.scout_compute_ap
 class scout_compute_api_ComputeNodeResponseVisitor:
 
     @abstractmethod
-    def _numeric(self, numeric: "scout_compute_api_NumericPlot") -> Any:
+    def _range(self, range: List["scout_compute_api_Range"]) -> Any:
         pass
 
     @abstractmethod
-    def _bucketed_numeric(self, bucketed_numeric: "scout_compute_api_BucketedNumericPlot") -> Any:
+    def _ranges_summary(self, ranges_summary: "scout_compute_api_RangesSummary") -> Any:
         pass
 
     @abstractmethod
-    def _range(self, range: List["scout_compute_api_Range"]) -> Any:
+    def _range_value(self, range_value: Optional["scout_compute_api_Range"]) -> Any:
         pass
 
     @abstractmethod
-    def _ranges_summary(self, ranges_summary: "scout_compute_api_RangesSummary") -> Any:
+    def _numeric(self, numeric: "scout_compute_api_NumericPlot") -> Any:
         pass
 
     @abstractmethod
-    def _enum(self, enum: "scout_compute_api_EnumPlot") -> Any:
+    def _bucketed_numeric(self, bucketed_numeric: "scout_compute_api_BucketedNumericPlot") -> Any:
         pass
 
     @abstractmethod
-    def _paged_log(self, paged_log: "scout_compute_api_PagedLogPlot") -> Any:
+    def _numeric_point(self, numeric_point: Optional["scout_compute_api_NumericPoint"]) -> Any:
         pass
 
     @abstractmethod
-    def _bucketed_enum(self, bucketed_enum: "scout_compute_api_BucketedEnumPlot") -> Any:
+    def _enum(self, enum: "scout_compute_api_EnumPlot") -> Any:
         pass
 
     @abstractmethod
-    def _cartesian(self, cartesian: "scout_compute_api_CartesianPlot") -> Any:
+    def _enum_point(self, enum_point: Optional["scout_compute_api_EnumPoint"]) -> Any:
         pass
 
     @abstractmethod
-    def _bucketed_cartesian(self, bucketed_cartesian: "scout_compute_api_BucketedCartesianPlot") -> Any:
+    def _bucketed_enum(self, bucketed_enum: "scout_compute_api_BucketedEnumPlot") -> Any:
         pass
 
     @abstractmethod
-    def _bucketed_cartesian3d(self, bucketed_cartesian3d: "scout_compute_api_BucketedCartesian3dPlot") -> Any:
+    def _paged_log(self, paged_log: "scout_compute_api_PagedLogPlot") -> Any:
         pass
 
     @abstractmethod
-    def _bucketed_geo(self, bucketed_geo: "scout_compute_api_BucketedGeoPlot") -> Any:
+    def _log_point(self, log_point: Optional["scout_compute_api_LogPoint"]) -> Any:
         pass
 
     @abstractmethod
-    def _enum_point(self, enum_point: Optional["scout_compute_api_EnumPoint"]) -> Any:
+    def _cartesian(self, cartesian: "scout_compute_api_CartesianPlot") -> Any:
         pass
 
     @abstractmethod
-    def _numeric_point(self, numeric_point: Optional["scout_compute_api_NumericPoint"]) -> Any:
+    def _bucketed_cartesian(self, bucketed_cartesian: "scout_compute_api_BucketedCartesianPlot") -> Any:
         pass
 
     @abstractmethod
-    def _log_point(self, log_point: Optional["scout_compute_api_LogPoint"]) -> Any:
+    def _bucketed_cartesian3d(self, bucketed_cartesian3d: "scout_compute_api_BucketedCartesian3dPlot") -> Any:
         pass
 
     @abstractmethod
-    def _range_value(self, range_value: Optional["scout_compute_api_Range"]) -> Any:
+    def _bucketed_geo(self, bucketed_geo: "scout_compute_api_BucketedGeoPlot") -> Any:
         pass
 
     @abstractmethod
@@ -37035,20 +37174,10 @@ class scout_compute_api_ExponentialCurve(ConjureBeanType):
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'intercept': ConjureFieldDefinition('intercept', OptionalTypeWrapper[scout_compute_api_DoubleConstant])
         }
 
-    __slots__: List[str] = ['_intercept']
-
-    def __init__(self, intercept: Optional["scout_compute_api_DoubleConstant"] = None) -> None:
-        self._intercept = intercept
+    __slots__: List[str] = []
 
-    @builtins.property
-    def intercept(self) -> Optional["scout_compute_api_DoubleConstant"]:
-        """
-        The y-value at the point x (or t) = 0. If omitted, the y-intercept will also be fit to the data.
-        """
-        return self._intercept
 
 
 scout_compute_api_ExponentialCurve.__name__ = "ExponentialCurve"
@@ -47091,804 +47220,6 @@ scout_compute_api_deprecated_WindowVisitor.__qualname__ = "WindowVisitor"
 scout_compute_api_deprecated_WindowVisitor.__module__ = "nominal_api.scout_compute_api_deprecated"
 
 
-class scout_compute_representation_api_BatchExpressionToComputeRequest(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'expressions': ConjureFieldDefinition('expressions', List[scout_compute_representation_api_ComputeExpression]),
-            'default_ref_name': ConjureFieldDefinition('defaultRefName', OptionalTypeWrapper[str])
-        }
-
-    __slots__: List[str] = ['_expressions', '_default_ref_name']
-
-    def __init__(self, expressions: List[str], default_ref_name: Optional[str] = None) -> None:
-        self._expressions = expressions
-        self._default_ref_name = default_ref_name
-
-    @builtins.property
-    def expressions(self) -> List[str]:
-        return self._expressions
-
-    @builtins.property
-    def default_ref_name(self) -> Optional[str]:
-        return self._default_ref_name
-
-
-scout_compute_representation_api_BatchExpressionToComputeRequest.__name__ = "BatchExpressionToComputeRequest"
-scout_compute_representation_api_BatchExpressionToComputeRequest.__qualname__ = "BatchExpressionToComputeRequest"
-scout_compute_representation_api_BatchExpressionToComputeRequest.__module__ = "nominal_api.scout_compute_representation_api"
-
-
-class scout_compute_representation_api_ChannelLocator(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'data_source_ref': ConjureFieldDefinition('dataSourceRef', scout_api_DataSourceRefName),
-            'channel': ConjureFieldDefinition('channel', api_Channel)
-        }
-
-    __slots__: List[str] = ['_data_source_ref', '_channel']
-
-    def __init__(self, channel: str, data_source_ref: str) -> None:
-        self._data_source_ref = data_source_ref
-        self._channel = channel
-
-    @builtins.property
-    def data_source_ref(self) -> str:
-        return self._data_source_ref
-
-    @builtins.property
-    def channel(self) -> str:
-        return self._channel
-
-
-scout_compute_representation_api_ChannelLocator.__name__ = "ChannelLocator"
-scout_compute_representation_api_ChannelLocator.__qualname__ = "ChannelLocator"
-scout_compute_representation_api_ChannelLocator.__module__ = "nominal_api.scout_compute_representation_api"
-
-
-class scout_compute_representation_api_CompiledEnumeratedSeries(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'node': ConjureFieldDefinition('node', scout_compute_api_EnumSeries),
-            'context': ConjureFieldDefinition('context', scout_compute_representation_api_ComputeRepresentationContext)
-        }
-
-    __slots__: List[str] = ['_node', '_context']
-
-    def __init__(self, context: "scout_compute_representation_api_ComputeRepresentationContext", node: "scout_compute_api_EnumSeries") -> None:
-        self._node = node
-        self._context = context
-
-    @builtins.property
-    def node(self) -> "scout_compute_api_EnumSeries":
-        return self._node
-
-    @builtins.property
-    def context(self) -> "scout_compute_representation_api_ComputeRepresentationContext":
-        return self._context
-
-
-scout_compute_representation_api_CompiledEnumeratedSeries.__name__ = "CompiledEnumeratedSeries"
-scout_compute_representation_api_CompiledEnumeratedSeries.__qualname__ = "CompiledEnumeratedSeries"
-scout_compute_representation_api_CompiledEnumeratedSeries.__module__ = "nominal_api.scout_compute_representation_api"
-
-
-class scout_compute_representation_api_CompiledNode(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'node': ConjureFieldDefinition('node', scout_compute_representation_api_Node),
-            'context': ConjureFieldDefinition('context', scout_compute_representation_api_ComputeRepresentationContext)
-        }
-
-    __slots__: List[str] = ['_node', '_context']
-
-    def __init__(self, context: "scout_compute_representation_api_ComputeRepresentationContext", node: "scout_compute_representation_api_Node") -> None:
-        self._node = node
-        self._context = context
-
-    @builtins.property
-    def node(self) -> "scout_compute_representation_api_Node":
-        return self._node
-
-    @builtins.property
-    def context(self) -> "scout_compute_representation_api_ComputeRepresentationContext":
-        return self._context
-
-
-scout_compute_representation_api_CompiledNode.__name__ = "CompiledNode"
-scout_compute_representation_api_CompiledNode.__qualname__ = "CompiledNode"
-scout_compute_representation_api_CompiledNode.__module__ = "nominal_api.scout_compute_representation_api"
-
-
-class scout_compute_representation_api_CompiledNumericSeries(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'node': ConjureFieldDefinition('node', scout_compute_api_NumericSeries),
-            'context': ConjureFieldDefinition('context', scout_compute_representation_api_ComputeRepresentationContext)
-        }
-
-    __slots__: List[str] = ['_node', '_context']
-
-    def __init__(self, context: "scout_compute_representation_api_ComputeRepresentationContext", node: "scout_compute_api_NumericSeries") -> None:
-        self._node = node
-        self._context = context
-
-    @builtins.property
-    def node(self) -> "scout_compute_api_NumericSeries":
-        return self._node
-
-    @builtins.property
-    def context(self) -> "scout_compute_representation_api_ComputeRepresentationContext":
-        return self._context
-
-
-scout_compute_representation_api_CompiledNumericSeries.__name__ = "CompiledNumericSeries"
-scout_compute_representation_api_CompiledNumericSeries.__qualname__ = "CompiledNumericSeries"
-scout_compute_representation_api_CompiledNumericSeries.__module__ = "nominal_api.scout_compute_representation_api"
-
-
-class scout_compute_representation_api_CompiledRangeSeries(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'node': ConjureFieldDefinition('node', scout_compute_api_RangeSeries),
-            'context': ConjureFieldDefinition('context', scout_compute_representation_api_ComputeRepresentationContext)
-        }
-
-    __slots__: List[str] = ['_node', '_context']
-
-    def __init__(self, context: "scout_compute_representation_api_ComputeRepresentationContext", node: "scout_compute_api_RangeSeries") -> None:
-        self._node = node
-        self._context = context
-
-    @builtins.property
-    def node(self) -> "scout_compute_api_RangeSeries":
-        return self._node
-
-    @builtins.property
-    def context(self) -> "scout_compute_representation_api_ComputeRepresentationContext":
-        return self._context
-
-
-scout_compute_representation_api_CompiledRangeSeries.__name__ = "CompiledRangeSeries"
-scout_compute_representation_api_CompiledRangeSeries.__qualname__ = "CompiledRangeSeries"
-scout_compute_representation_api_CompiledRangeSeries.__module__ = "nominal_api.scout_compute_representation_api"
-
-
-class scout_compute_representation_api_ComputeRepresentationContext(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'variables': ConjureFieldDefinition('variables', Dict[scout_compute_api_VariableName, scout_compute_representation_api_ComputeRepresentationVariableValue]),
-            'function_variables': ConjureFieldDefinition('functionVariables', Dict[scout_compute_api_FunctionReference, scout_compute_representation_api_ComputeRepresentationContext])
-        }
-
-    __slots__: List[str] = ['_variables', '_function_variables']
-
-    def __init__(self, function_variables: Dict[str, "scout_compute_representation_api_ComputeRepresentationContext"], variables: Dict[str, "scout_compute_representation_api_ComputeRepresentationVariableValue"]) -> None:
-        self._variables = variables
-        self._function_variables = function_variables
-
-    @builtins.property
-    def variables(self) -> Dict[str, "scout_compute_representation_api_ComputeRepresentationVariableValue"]:
-        return self._variables
-
-    @builtins.property
-    def function_variables(self) -> Dict[str, "scout_compute_representation_api_ComputeRepresentationContext"]:
-        return self._function_variables
-
-
-scout_compute_representation_api_ComputeRepresentationContext.__name__ = "ComputeRepresentationContext"
-scout_compute_representation_api_ComputeRepresentationContext.__qualname__ = "ComputeRepresentationContext"
-scout_compute_representation_api_ComputeRepresentationContext.__module__ = "nominal_api.scout_compute_representation_api"
-
-
-class scout_compute_representation_api_ComputeRepresentationService(Service):
-    """
-    The Compute Representation Service provides the ability to translate between a human-readable expression language
-and a compute graph. Bidirectional translation is supported.
-    """
-
-    def compute_to_expression(self, auth_header: str, request: "scout_compute_representation_api_CompiledNode") -> str:
-        """
-        Converts a compute graph and its context into a its expression language representation.
-        """
-
-        _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(request)
-
-        _path = '/compute/representation/v1/compute-to-expression'
-        _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(), scout_compute_representation_api_ComputeExpression, self._return_none_for_unknown_union_types)
-
-    def batch_compute_to_expression(self, auth_header: str, request: Dict[str, "scout_compute_representation_api_CompiledNode"]) -> Dict[str, str]:
-        """
-        Converts a batch of compute graphs and their contexts into their expression language representation. Requires
-a string key reference to be provided for each graph.
-        """
-
-        _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(request)
-
-        _path = '/compute/representation/v1/batch-compute-to-expression'
-        _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(), Dict[str, scout_compute_representation_api_ComputeExpression], self._return_none_for_unknown_union_types)
-
-    def expression_to_compute(self, auth_header: str, request: "scout_compute_representation_api_ExpressionToComputeRequest") -> "scout_compute_representation_api_ExpressionToComputeResult":
-        """
-        Converts an expression language representation into a compute graph. The outputted graph can be passed to
-the compute service or checks service for execution.
-        """
-
-        _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(request)
-
-        _path = '/compute/representation/v1/expression-to-compute'
-        _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(), scout_compute_representation_api_ExpressionToComputeResult, self._return_none_for_unknown_union_types)
-
-    def batch_expression_to_compute(self, auth_header: str, request: "scout_compute_representation_api_BatchExpressionToComputeRequest") -> Dict[str, "scout_compute_representation_api_ExpressionToComputeResult"]:
-        """
-        Converts a batch of expressions into their compute graph representation.
-        """
-
-        _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(request)
-
-        _path = '/compute/representation/v1/batch-expression-to-compute'
-        _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(), Dict[scout_compute_representation_api_ComputeExpression, scout_compute_representation_api_ExpressionToComputeResult], self._return_none_for_unknown_union_types)
-
-
-scout_compute_representation_api_ComputeRepresentationService.__name__ = "ComputeRepresentationService"
-scout_compute_representation_api_ComputeRepresentationService.__qualname__ = "ComputeRepresentationService"
-scout_compute_representation_api_ComputeRepresentationService.__module__ = "nominal_api.scout_compute_representation_api"
-
-
-class scout_compute_representation_api_ComputeRepresentationVariableValue(ConjureUnionType):
-    _double: Optional[float] = None
-    _duration: Optional["scout_run_api_Duration"] = None
-    _integer: Optional[int] = None
-    _string_set: Optional[List[str]] = None
-    _timestamp: Optional["api_Timestamp"] = None
-    _function_rid: Optional[str] = None
-    _series: Optional["scout_compute_representation_api_ChannelLocator"] = None
-    _external_variable_reference: Optional[str] = None
-
-    @builtins.classmethod
-    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'double': ConjureFieldDefinition('double', float),
-            'duration': ConjureFieldDefinition('duration', scout_run_api_Duration),
-            'integer': ConjureFieldDefinition('integer', int),
-            'string_set': ConjureFieldDefinition('stringSet', List[str]),
-            'timestamp': ConjureFieldDefinition('timestamp', api_Timestamp),
-            'function_rid': ConjureFieldDefinition('functionRid', scout_rids_api_FunctionRid),
-            'series': ConjureFieldDefinition('series', scout_compute_representation_api_ChannelLocator),
-            'external_variable_reference': ConjureFieldDefinition('externalVariableReference', str)
-        }
-
-    def __init__(
-            self,
-            double: Optional[float] = None,
-            duration: Optional["scout_run_api_Duration"] = None,
-            integer: Optional[int] = None,
-            string_set: Optional[List[str]] = None,
-            timestamp: Optional["api_Timestamp"] = None,
-            function_rid: Optional[str] = None,
-            series: Optional["scout_compute_representation_api_ChannelLocator"] = None,
-            external_variable_reference: Optional[str] = None,
-            type_of_union: Optional[str] = None
-            ) -> None:
-        if type_of_union is None:
-            if (double is not None) + (duration is not None) + (integer is not None) + (string_set is not None) + (timestamp is not None) + (function_rid is not None) + (series is not None) + (external_variable_reference is not None) != 1:
-                raise ValueError('a union must contain a single member')
-
-            if double is not None:
-                self._double = double
-                self._type = 'double'
-            if duration is not None:
-                self._duration = duration
-                self._type = 'duration'
-            if integer is not None:
-                self._integer = integer
-                self._type = 'integer'
-            if string_set is not None:
-                self._string_set = string_set
-                self._type = 'stringSet'
-            if timestamp is not None:
-                self._timestamp = timestamp
-                self._type = 'timestamp'
-            if function_rid is not None:
-                self._function_rid = function_rid
-                self._type = 'functionRid'
-            if series is not None:
-                self._series = series
-                self._type = 'series'
-            if external_variable_reference is not None:
-                self._external_variable_reference = external_variable_reference
-                self._type = 'externalVariableReference'
-
-        elif type_of_union == 'double':
-            if double is None:
-                raise ValueError('a union value must not be None')
-            self._double = double
-            self._type = 'double'
-        elif type_of_union == 'duration':
-            if duration is None:
-                raise ValueError('a union value must not be None')
-            self._duration = duration
-            self._type = 'duration'
-        elif type_of_union == 'integer':
-            if integer is None:
-                raise ValueError('a union value must not be None')
-            self._integer = integer
-            self._type = 'integer'
-        elif type_of_union == 'stringSet':
-            if string_set is None:
-                raise ValueError('a union value must not be None')
-            self._string_set = string_set
-            self._type = 'stringSet'
-        elif type_of_union == 'timestamp':
-            if timestamp is None:
-                raise ValueError('a union value must not be None')
-            self._timestamp = timestamp
-            self._type = 'timestamp'
-        elif type_of_union == 'functionRid':
-            if function_rid is None:
-                raise ValueError('a union value must not be None')
-            self._function_rid = function_rid
-            self._type = 'functionRid'
-        elif type_of_union == 'series':
-            if series is None:
-                raise ValueError('a union value must not be None')
-            self._series = series
-            self._type = 'series'
-        elif type_of_union == 'externalVariableReference':
-            if external_variable_reference is None:
-                raise ValueError('a union value must not be None')
-            self._external_variable_reference = external_variable_reference
-            self._type = 'externalVariableReference'
-
-    @builtins.property
-    def double(self) -> Optional[float]:
-        return self._double
-
-    @builtins.property
-    def duration(self) -> Optional["scout_run_api_Duration"]:
-        return self._duration
-
-    @builtins.property
-    def integer(self) -> Optional[int]:
-        return self._integer
-
-    @builtins.property
-    def string_set(self) -> Optional[List[str]]:
-        return self._string_set
-
-    @builtins.property
-    def timestamp(self) -> Optional["api_Timestamp"]:
-        return self._timestamp
-
-    @builtins.property
-    def function_rid(self) -> Optional[str]:
-        return self._function_rid
-
-    @builtins.property
-    def series(self) -> Optional["scout_compute_representation_api_ChannelLocator"]:
-        return self._series
-
-    @builtins.property
-    def external_variable_reference(self) -> Optional[str]:
-        return self._external_variable_reference
-
-    def accept(self, visitor) -> Any:
-        if not isinstance(visitor, scout_compute_representation_api_ComputeRepresentationVariableValueVisitor):
-            raise ValueError('{} is not an instance of scout_compute_representation_api_ComputeRepresentationVariableValueVisitor'.format(visitor.__class__.__name__))
-        if self._type == 'double' and self.double is not None:
-            return visitor._double(self.double)
-        if self._type == 'duration' and self.duration is not None:
-            return visitor._duration(self.duration)
-        if self._type == 'integer' and self.integer is not None:
-            return visitor._integer(self.integer)
-        if self._type == 'stringSet' and self.string_set is not None:
-            return visitor._string_set(self.string_set)
-        if self._type == 'timestamp' and self.timestamp is not None:
-            return visitor._timestamp(self.timestamp)
-        if self._type == 'functionRid' and self.function_rid is not None:
-            return visitor._function_rid(self.function_rid)
-        if self._type == 'series' and self.series is not None:
-            return visitor._series(self.series)
-        if self._type == 'externalVariableReference' and self.external_variable_reference is not None:
-            return visitor._external_variable_reference(self.external_variable_reference)
-
-
-scout_compute_representation_api_ComputeRepresentationVariableValue.__name__ = "ComputeRepresentationVariableValue"
-scout_compute_representation_api_ComputeRepresentationVariableValue.__qualname__ = "ComputeRepresentationVariableValue"
-scout_compute_representation_api_ComputeRepresentationVariableValue.__module__ = "nominal_api.scout_compute_representation_api"
-
-
-class scout_compute_representation_api_ComputeRepresentationVariableValueVisitor:
-
-    @abstractmethod
-    def _double(self, double: float) -> Any:
-        pass
-
-    @abstractmethod
-    def _duration(self, duration: "scout_run_api_Duration") -> Any:
-        pass
-
-    @abstractmethod
-    def _integer(self, integer: int) -> Any:
-        pass
-
-    @abstractmethod
-    def _string_set(self, string_set: List[str]) -> Any:
-        pass
-
-    @abstractmethod
-    def _timestamp(self, timestamp: "api_Timestamp") -> Any:
-        pass
-
-    @abstractmethod
-    def _function_rid(self, function_rid: str) -> Any:
-        pass
-
-    @abstractmethod
-    def _series(self, series: "scout_compute_representation_api_ChannelLocator") -> Any:
-        pass
-
-    @abstractmethod
-    def _external_variable_reference(self, external_variable_reference: str) -> Any:
-        pass
-
-
-scout_compute_representation_api_ComputeRepresentationVariableValueVisitor.__name__ = "ComputeRepresentationVariableValueVisitor"
-scout_compute_representation_api_ComputeRepresentationVariableValueVisitor.__qualname__ = "ComputeRepresentationVariableValueVisitor"
-scout_compute_representation_api_ComputeRepresentationVariableValueVisitor.__module__ = "nominal_api.scout_compute_representation_api"
-
-
-class scout_compute_representation_api_ErrorExpressionToComputeResult(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'error_message': ConjureFieldDefinition('errorMessage', str)
-        }
-
-    __slots__: List[str] = ['_error_message']
-
-    def __init__(self, error_message: str) -> None:
-        self._error_message = error_message
-
-    @builtins.property
-    def error_message(self) -> str:
-        return self._error_message
-
-
-scout_compute_representation_api_ErrorExpressionToComputeResult.__name__ = "ErrorExpressionToComputeResult"
-scout_compute_representation_api_ErrorExpressionToComputeResult.__qualname__ = "ErrorExpressionToComputeResult"
-scout_compute_representation_api_ErrorExpressionToComputeResult.__module__ = "nominal_api.scout_compute_representation_api"
-
-
-class scout_compute_representation_api_ExpressionToComputeRequest(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'expression': ConjureFieldDefinition('expression', scout_compute_representation_api_ComputeExpression),
-            'default_ref_name': ConjureFieldDefinition('defaultRefName', OptionalTypeWrapper[str])
-        }
-
-    __slots__: List[str] = ['_expression', '_default_ref_name']
-
-    def __init__(self, expression: str, default_ref_name: Optional[str] = None) -> None:
-        self._expression = expression
-        self._default_ref_name = default_ref_name
-
-    @builtins.property
-    def expression(self) -> str:
-        return self._expression
-
-    @builtins.property
-    def default_ref_name(self) -> Optional[str]:
-        return self._default_ref_name
-
-
-scout_compute_representation_api_ExpressionToComputeRequest.__name__ = "ExpressionToComputeRequest"
-scout_compute_representation_api_ExpressionToComputeRequest.__qualname__ = "ExpressionToComputeRequest"
-scout_compute_representation_api_ExpressionToComputeRequest.__module__ = "nominal_api.scout_compute_representation_api"
-
-
-class scout_compute_representation_api_ExpressionToComputeResult(ConjureUnionType):
-    _success: Optional["scout_compute_representation_api_SuccessExpressionToComputeResult"] = None
-    _error: Optional["scout_compute_representation_api_ErrorExpressionToComputeResult"] = None
-
-    @builtins.classmethod
-    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'success': ConjureFieldDefinition('success', scout_compute_representation_api_SuccessExpressionToComputeResult),
-            'error': ConjureFieldDefinition('error', scout_compute_representation_api_ErrorExpressionToComputeResult)
-        }
-
-    def __init__(
-            self,
-            success: Optional["scout_compute_representation_api_SuccessExpressionToComputeResult"] = None,
-            error: Optional["scout_compute_representation_api_ErrorExpressionToComputeResult"] = None,
-            type_of_union: Optional[str] = None
-            ) -> None:
-        if type_of_union is None:
-            if (success is not None) + (error is not None) != 1:
-                raise ValueError('a union must contain a single member')
-
-            if success is not None:
-                self._success = success
-                self._type = 'success'
-            if error is not None:
-                self._error = error
-                self._type = 'error'
-
-        elif type_of_union == 'success':
-            if success is None:
-                raise ValueError('a union value must not be None')
-            self._success = success
-            self._type = 'success'
-        elif type_of_union == 'error':
-            if error is None:
-                raise ValueError('a union value must not be None')
-            self._error = error
-            self._type = 'error'
-
-    @builtins.property
-    def success(self) -> Optional["scout_compute_representation_api_SuccessExpressionToComputeResult"]:
-        return self._success
-
-    @builtins.property
-    def error(self) -> Optional["scout_compute_representation_api_ErrorExpressionToComputeResult"]:
-        return self._error
-
-    def accept(self, visitor) -> Any:
-        if not isinstance(visitor, scout_compute_representation_api_ExpressionToComputeResultVisitor):
-            raise ValueError('{} is not an instance of scout_compute_representation_api_ExpressionToComputeResultVisitor'.format(visitor.__class__.__name__))
-        if self._type == 'success' and self.success is not None:
-            return visitor._success(self.success)
-        if self._type == 'error' and self.error is not None:
-            return visitor._error(self.error)
-
-
-scout_compute_representation_api_ExpressionToComputeResult.__name__ = "ExpressionToComputeResult"
-scout_compute_representation_api_ExpressionToComputeResult.__qualname__ = "ExpressionToComputeResult"
-scout_compute_representation_api_ExpressionToComputeResult.__module__ = "nominal_api.scout_compute_representation_api"
-
-
-class scout_compute_representation_api_ExpressionToComputeResultVisitor:
-
-    @abstractmethod
-    def _success(self, success: "scout_compute_representation_api_SuccessExpressionToComputeResult") -> Any:
-        pass
-
-    @abstractmethod
-    def _error(self, error: "scout_compute_representation_api_ErrorExpressionToComputeResult") -> Any:
-        pass
-
-
-scout_compute_representation_api_ExpressionToComputeResultVisitor.__name__ = "ExpressionToComputeResultVisitor"
-scout_compute_representation_api_ExpressionToComputeResultVisitor.__qualname__ = "ExpressionToComputeResultVisitor"
-scout_compute_representation_api_ExpressionToComputeResultVisitor.__module__ = "nominal_api.scout_compute_representation_api"
-
-
-class scout_compute_representation_api_Node(ConjureUnionType):
-    _enumerated_series: Optional["scout_compute_api_EnumSeries"] = None
-    _numeric_series: Optional["scout_compute_api_NumericSeries"] = None
-    _range_series: Optional["scout_compute_api_RangeSeries"] = None
-
-    @builtins.classmethod
-    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'enumerated_series': ConjureFieldDefinition('enumeratedSeries', scout_compute_api_EnumSeries),
-            'numeric_series': ConjureFieldDefinition('numericSeries', scout_compute_api_NumericSeries),
-            'range_series': ConjureFieldDefinition('rangeSeries', scout_compute_api_RangeSeries)
-        }
-
-    def __init__(
-            self,
-            enumerated_series: Optional["scout_compute_api_EnumSeries"] = None,
-            numeric_series: Optional["scout_compute_api_NumericSeries"] = None,
-            range_series: Optional["scout_compute_api_RangeSeries"] = None,
-            type_of_union: Optional[str] = None
-            ) -> None:
-        if type_of_union is None:
-            if (enumerated_series is not None) + (numeric_series is not None) + (range_series is not None) != 1:
-                raise ValueError('a union must contain a single member')
-
-            if enumerated_series is not None:
-                self._enumerated_series = enumerated_series
-                self._type = 'enumeratedSeries'
-            if numeric_series is not None:
-                self._numeric_series = numeric_series
-                self._type = 'numericSeries'
-            if range_series is not None:
-                self._range_series = range_series
-                self._type = 'rangeSeries'
-
-        elif type_of_union == 'enumeratedSeries':
-            if enumerated_series is None:
-                raise ValueError('a union value must not be None')
-            self._enumerated_series = enumerated_series
-            self._type = 'enumeratedSeries'
-        elif type_of_union == 'numericSeries':
-            if numeric_series is None:
-                raise ValueError('a union value must not be None')
-            self._numeric_series = numeric_series
-            self._type = 'numericSeries'
-        elif type_of_union == 'rangeSeries':
-            if range_series is None:
-                raise ValueError('a union value must not be None')
-            self._range_series = range_series
-            self._type = 'rangeSeries'
-
-    @builtins.property
-    def enumerated_series(self) -> Optional["scout_compute_api_EnumSeries"]:
-        return self._enumerated_series
-
-    @builtins.property
-    def numeric_series(self) -> Optional["scout_compute_api_NumericSeries"]:
-        return self._numeric_series
-
-    @builtins.property
-    def range_series(self) -> Optional["scout_compute_api_RangeSeries"]:
-        return self._range_series
-
-    def accept(self, visitor) -> Any:
-        if not isinstance(visitor, scout_compute_representation_api_NodeVisitor):
-            raise ValueError('{} is not an instance of scout_compute_representation_api_NodeVisitor'.format(visitor.__class__.__name__))
-        if self._type == 'enumeratedSeries' and self.enumerated_series is not None:
-            return visitor._enumerated_series(self.enumerated_series)
-        if self._type == 'numericSeries' and self.numeric_series is not None:
-            return visitor._numeric_series(self.numeric_series)
-        if self._type == 'rangeSeries' and self.range_series is not None:
-            return visitor._range_series(self.range_series)
-
-
-scout_compute_representation_api_Node.__name__ = "Node"
-scout_compute_representation_api_Node.__qualname__ = "Node"
-scout_compute_representation_api_Node.__module__ = "nominal_api.scout_compute_representation_api"
-
-
-class scout_compute_representation_api_NodeVisitor:
-
-    @abstractmethod
-    def _enumerated_series(self, enumerated_series: "scout_compute_api_EnumSeries") -> Any:
-        pass
-
-    @abstractmethod
-    def _numeric_series(self, numeric_series: "scout_compute_api_NumericSeries") -> Any:
-        pass
-
-    @abstractmethod
-    def _range_series(self, range_series: "scout_compute_api_RangeSeries") -> Any:
-        pass
-
-
-scout_compute_representation_api_NodeVisitor.__name__ = "NodeVisitor"
-scout_compute_representation_api_NodeVisitor.__qualname__ = "NodeVisitor"
-scout_compute_representation_api_NodeVisitor.__module__ = "nominal_api.scout_compute_representation_api"
-
-
-class scout_compute_representation_api_SuccessExpressionToComputeResult(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'node': ConjureFieldDefinition('node', scout_compute_representation_api_CompiledNode)
-        }
-
-    __slots__: List[str] = ['_node']
-
-    def __init__(self, node: "scout_compute_representation_api_CompiledNode") -> None:
-        self._node = node
-
-    @builtins.property
-    def node(self) -> "scout_compute_representation_api_CompiledNode":
-        return self._node
-
-
-scout_compute_representation_api_SuccessExpressionToComputeResult.__name__ = "SuccessExpressionToComputeResult"
-scout_compute_representation_api_SuccessExpressionToComputeResult.__qualname__ = "SuccessExpressionToComputeResult"
-scout_compute_representation_api_SuccessExpressionToComputeResult.__module__ = "nominal_api.scout_compute_representation_api"
-
-
 class scout_compute_resolved_api_AbsoluteThreshold(ConjureBeanType):
 
     @builtins.classmethod
@@ -49220,17 +48551,10 @@ class scout_compute_resolved_api_ExponentialCurve(ConjureBeanType):
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'intercept': ConjureFieldDefinition('intercept', OptionalTypeWrapper[float])
         }
 
-    __slots__: List[str] = ['_intercept']
-
-    def __init__(self, intercept: Optional[float] = None) -> None:
-        self._intercept = intercept
+    __slots__: List[str] = []
 
-    @builtins.property
-    def intercept(self) -> Optional[float]:
-        return self._intercept
 
 
 scout_compute_resolved_api_ExponentialCurve.__name__ = "ExponentialCurve"
@@ -65484,6 +64808,29 @@ scout_notebook_api_UpdateNotebookRequest.__qualname__ = "UpdateNotebookRequest"
 scout_notebook_api_UpdateNotebookRequest.__module__ = "nominal_api.scout_notebook_api"
 
 
+class scout_notebook_api_UpdateRefNameRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'ref_name_updates': ConjureFieldDefinition('refNameUpdates', Dict[scout_api_DataSourceRefName, scout_api_DataSourceRefName])
+        }
+
+    __slots__: List[str] = ['_ref_name_updates']
+
+    def __init__(self, ref_name_updates: Dict[str, str]) -> None:
+        self._ref_name_updates = ref_name_updates
+
+    @builtins.property
+    def ref_name_updates(self) -> Dict[str, str]:
+        return self._ref_name_updates
+
+
+scout_notebook_api_UpdateRefNameRequest.__name__ = "UpdateRefNameRequest"
+scout_notebook_api_UpdateRefNameRequest.__qualname__ = "UpdateRefNameRequest"
+scout_notebook_api_UpdateRefNameRequest.__module__ = "nominal_api.scout_notebook_api"
+
+
 class scout_plotting_TimestampType(ConjureEnumType):
 
     ABSOLUTE = 'ABSOLUTE'
@@ -68519,6 +67866,39 @@ scout_template_api_UpdateMetadataRequest.__qualname__ = "UpdateMetadataRequest"
 scout_template_api_UpdateMetadataRequest.__module__ = "nominal_api.scout_template_api"
 
 
+class scout_template_api_UpdateRefNameRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'ref_name_updates': ConjureFieldDefinition('refNameUpdates', Dict[scout_api_DataSourceRefName, scout_api_DataSourceRefName]),
+            'latest_commit': ConjureFieldDefinition('latestCommit', OptionalTypeWrapper[scout_versioning_api_CommitId])
+        }
+
+    __slots__: List[str] = ['_ref_name_updates', '_latest_commit']
+
+    def __init__(self, ref_name_updates: Dict[str, str], latest_commit: Optional[str] = None) -> None:
+        self._ref_name_updates = ref_name_updates
+        self._latest_commit = latest_commit
+
+    @builtins.property
+    def ref_name_updates(self) -> Dict[str, str]:
+        return self._ref_name_updates
+
+    @builtins.property
+    def latest_commit(self) -> Optional[str]:
+        """
+        If present, will validate that the latest commit matches this id,
+and otherwise throw CommitConflict.
+        """
+        return self._latest_commit
+
+
+scout_template_api_UpdateRefNameRequest.__name__ = "UpdateRefNameRequest"
+scout_template_api_UpdateRefNameRequest.__qualname__ = "UpdateRefNameRequest"
+scout_template_api_UpdateRefNameRequest.__module__ = "nominal_api.scout_template_api"
+
+
 class scout_units_api_GetUnitsResponse(ConjureBeanType):
 
     @builtins.classmethod
@@ -73700,8 +73080,9 @@ Nominal live within a workspace.
 
     def get_default_workspace(self, auth_header: str) -> Optional["security_api_workspace_Workspace"]:
         """
-        Gets the default workspace for the requesting user. It may not be present if the user does not have
-access to any workspaces or no default workspace is configured for the user's organization.
+        Gets the default workspace for the requesting user. If the user belongs to a single workspace,
+that workspace is returned. Otherwise, if the user's organization has a default workspace and
+the user belongs to it, that will be returned.
         """
 
         _headers: Dict[str, Any] = {
@@ -79683,8 +79064,6 @@ timeseries_logicalseries_api_MeasurementName = str
 
 themes_api_HexColor = str
 
-scout_compute_representation_api_ComputeExpression = str
-
 scout_datasource_connection_api_ColumnName = str
 
 storage_writer_api_Field = str