nominal-api 0.633.0__py3-none-any.whl → 0.636.0__py3-none-any.whl

nominal_api/_impl.py

@@ -16925,7 +16925,7 @@ Throws if the asset already has data scopes with data scope names matching those
         _decoder = ConjureDecoder()
         return _decoder.decode(_response.json(), Dict[scout_rids_api_AssetRid, scout_asset_api_Asset], self._return_none_for_unknown_union_types)
 
-    def archive(self, auth_header: str, rid: str) -> None:
+    def archive(self, auth_header: str, rid: str, include_linked_workbooks: Optional[bool] = None) -> None:
 
         _headers: Dict[str, Any] = {
             'Accept': 'application/json',
@@ -16933,6 +16933,7 @@ Throws if the asset already has data scopes with data scope names matching those
         }
 
         _params: Dict[str, Any] = {
+            'includeLinkedWorkbooks': include_linked_workbooks,
         }
 
         _path_params: Dict[str, Any] = {
@@ -33428,6 +33429,7 @@ class scout_compute_api_ComputableNode(ConjureUnionType):
     _frequency: Optional["scout_compute_api_FrequencyDomain"] = None
     _histogram: Optional["scout_compute_api_Histogram"] = None
     _geo: Optional["scout_compute_api_SummarizeGeo"] = None
+    _curve: Optional["scout_compute_api_CurveFit"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
@@ -33439,7 +33441,8 @@ class scout_compute_api_ComputableNode(ConjureUnionType):
             'cartesian3d': ConjureFieldDefinition('cartesian3d', scout_compute_api_SummarizeCartesian3d),
             'frequency': ConjureFieldDefinition('frequency', scout_compute_api_FrequencyDomain),
             'histogram': ConjureFieldDefinition('histogram', scout_compute_api_Histogram),
-            'geo': ConjureFieldDefinition('geo', scout_compute_api_SummarizeGeo)
+            'geo': ConjureFieldDefinition('geo', scout_compute_api_SummarizeGeo),
+            'curve': ConjureFieldDefinition('curve', scout_compute_api_CurveFit)
         }
 
     def __init__(
@@ -33452,10 +33455,11 @@ class scout_compute_api_ComputableNode(ConjureUnionType):
             frequency: Optional["scout_compute_api_FrequencyDomain"] = None,
             histogram: Optional["scout_compute_api_Histogram"] = None,
             geo: Optional["scout_compute_api_SummarizeGeo"] = None,
+            curve: Optional["scout_compute_api_CurveFit"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (ranges is not None) + (series is not None) + (value is not None) + (cartesian is not None) + (cartesian3d is not None) + (frequency is not None) + (histogram is not None) + (geo is not None) != 1:
+            if (ranges is not None) + (series is not None) + (value is not None) + (cartesian is not None) + (cartesian3d is not None) + (frequency is not None) + (histogram is not None) + (geo is not None) + (curve is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if ranges is not None:
@@ -33482,6 +33486,9 @@ class scout_compute_api_ComputableNode(ConjureUnionType):
             if geo is not None:
                 self._geo = geo
                 self._type = 'geo'
+            if curve is not None:
+                self._curve = curve
+                self._type = 'curve'
 
         elif type_of_union == 'ranges':
             if ranges is None:
@@ -33523,6 +33530,11 @@ class scout_compute_api_ComputableNode(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._geo = geo
             self._type = 'geo'
+        elif type_of_union == 'curve':
+            if curve is None:
+                raise ValueError('a union value must not be None')
+            self._curve = curve
+            self._type = 'curve'
 
     @builtins.property
     def ranges(self) -> Optional["scout_compute_api_SummarizeRanges"]:
@@ -33556,6 +33568,10 @@ class scout_compute_api_ComputableNode(ConjureUnionType):
     def geo(self) -> Optional["scout_compute_api_SummarizeGeo"]:
         return self._geo
 
+    @builtins.property
+    def curve(self) -> Optional["scout_compute_api_CurveFit"]:
+        return self._curve
+
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, scout_compute_api_ComputableNodeVisitor):
             raise ValueError('{} is not an instance of scout_compute_api_ComputableNodeVisitor'.format(visitor.__class__.__name__))
@@ -33575,6 +33591,8 @@ class scout_compute_api_ComputableNode(ConjureUnionType):
             return visitor._histogram(self.histogram)
         if self._type == 'geo' and self.geo is not None:
             return visitor._geo(self.geo)
+        if self._type == 'curve' and self.curve is not None:
+            return visitor._curve(self.curve)
 
 
 scout_compute_api_ComputableNode.__name__ = "ComputableNode"
@@ -33616,6 +33634,10 @@ class scout_compute_api_ComputableNodeVisitor:
     def _geo(self, geo: "scout_compute_api_SummarizeGeo") -> Any:
         pass
 
+    @abstractmethod
+    def _curve(self, curve: "scout_compute_api_CurveFit") -> Any:
+        pass
+
 
 scout_compute_api_ComputableNodeVisitor.__name__ = "ComputableNodeVisitor"
 scout_compute_api_ComputableNodeVisitor.__qualname__ = "ComputableNodeVisitor"
@@ -33863,6 +33885,7 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
     _frequency_domain: Optional["scout_compute_api_FrequencyDomainPlot"] = None
     _numeric_histogram: Optional["scout_compute_api_NumericHistogramPlot"] = None
     _enum_histogram: Optional["scout_compute_api_EnumHistogramPlot"] = None
+    _curve_fit: Optional["scout_compute_api_CurveFitResult"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
@@ -33884,7 +33907,8 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
             '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)
+            'enum_histogram': ConjureFieldDefinition('enumHistogram', scout_compute_api_EnumHistogramPlot),
+            'curve_fit': ConjureFieldDefinition('curveFit', scout_compute_api_CurveFitResult)
         }
 
     def __init__(
@@ -33907,10 +33931,11 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
             frequency_domain: Optional["scout_compute_api_FrequencyDomainPlot"] = None,
             numeric_histogram: Optional["scout_compute_api_NumericHistogramPlot"] = None,
             enum_histogram: Optional["scout_compute_api_EnumHistogramPlot"] = None,
+            curve_fit: Optional["scout_compute_api_CurveFitResult"] = None,
             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) != 1:
+            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:
                 raise ValueError('a union must contain a single member')
 
             if numeric is not None:
@@ -33967,6 +33992,9 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
             if enum_histogram is not None:
                 self._enum_histogram = enum_histogram
                 self._type = 'enumHistogram'
+            if curve_fit is not None:
+                self._curve_fit = curve_fit
+                self._type = 'curveFit'
 
         elif type_of_union == 'numeric':
             if numeric is None:
@@ -34058,6 +34086,11 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._enum_histogram = enum_histogram
             self._type = 'enumHistogram'
+        elif type_of_union == 'curveFit':
+            if curve_fit is None:
+                raise ValueError('a union value must not be None')
+            self._curve_fit = curve_fit
+            self._type = 'curveFit'
 
     @builtins.property
     def numeric(self) -> Optional["scout_compute_api_NumericPlot"]:
@@ -34131,6 +34164,10 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
     def enum_histogram(self) -> Optional["scout_compute_api_EnumHistogramPlot"]:
         return self._enum_histogram
 
+    @builtins.property
+    def curve_fit(self) -> Optional["scout_compute_api_CurveFitResult"]:
+        return self._curve_fit
+
     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__))
@@ -34170,6 +34207,8 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
             return visitor._numeric_histogram(self.numeric_histogram)
         if self._type == 'enumHistogram' and self.enum_histogram is not None:
             return visitor._enum_histogram(self.enum_histogram)
+        if self._type == 'curveFit' and self.curve_fit is not None:
+            return visitor._curve_fit(self.curve_fit)
 
 
 scout_compute_api_ComputeNodeResponse.__name__ = "ComputeNodeResponse"
@@ -34251,6 +34290,10 @@ class scout_compute_api_ComputeNodeResponseVisitor:
     def _enum_histogram(self, enum_histogram: "scout_compute_api_EnumHistogramPlot") -> Any:
         pass
 
+    @abstractmethod
+    def _curve_fit(self, curve_fit: "scout_compute_api_CurveFitResult") -> Any:
+        pass
+
 
 scout_compute_api_ComputeNodeResponseVisitor.__name__ = "ComputeNodeResponseVisitor"
 scout_compute_api_ComputeNodeResponseVisitor.__qualname__ = "ComputeNodeResponseVisitor"
@@ -34849,6 +34892,408 @@ scout_compute_api_CumulativeSumSeries.__qualname__ = "CumulativeSumSeries"
 scout_compute_api_CumulativeSumSeries.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_CurveFit(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'curve_fit_plot_type': ConjureFieldDefinition('curveFitPlotType', scout_compute_api_CurveFitPlotType),
+            'curve_fit_details': ConjureFieldDefinition('curveFitDetails', scout_compute_api_CurveFitDetails),
+            'curve_fit_options': ConjureFieldDefinition('curveFitOptions', scout_compute_api_CurveFitOptions)
+        }
+
+    __slots__: List[str] = ['_curve_fit_plot_type', '_curve_fit_details', '_curve_fit_options']
+
+    def __init__(self, curve_fit_details: "scout_compute_api_CurveFitDetails", curve_fit_options: "scout_compute_api_CurveFitOptions", curve_fit_plot_type: "scout_compute_api_CurveFitPlotType") -> None:
+        self._curve_fit_plot_type = curve_fit_plot_type
+        self._curve_fit_details = curve_fit_details
+        self._curve_fit_options = curve_fit_options
+
+    @builtins.property
+    def curve_fit_plot_type(self) -> "scout_compute_api_CurveFitPlotType":
+        return self._curve_fit_plot_type
+
+    @builtins.property
+    def curve_fit_details(self) -> "scout_compute_api_CurveFitDetails":
+        return self._curve_fit_details
+
+    @builtins.property
+    def curve_fit_options(self) -> "scout_compute_api_CurveFitOptions":
+        return self._curve_fit_options
+
+
+scout_compute_api_CurveFit.__name__ = "CurveFit"
+scout_compute_api_CurveFit.__qualname__ = "CurveFit"
+scout_compute_api_CurveFit.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_CurveFitDetails(ConjureUnionType):
+    _exponential: Optional["scout_compute_api_ExponentialCurve"] = None
+    _logarithmic: Optional["scout_compute_api_LogarithmicCurve"] = None
+    _polynomial: Optional["scout_compute_api_PolynomialCurve"] = None
+    _power: Optional["scout_compute_api_PowerCurve"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'exponential': ConjureFieldDefinition('exponential', scout_compute_api_ExponentialCurve),
+            'logarithmic': ConjureFieldDefinition('logarithmic', scout_compute_api_LogarithmicCurve),
+            'polynomial': ConjureFieldDefinition('polynomial', scout_compute_api_PolynomialCurve),
+            'power': ConjureFieldDefinition('power', scout_compute_api_PowerCurve)
+        }
+
+    def __init__(
+            self,
+            exponential: Optional["scout_compute_api_ExponentialCurve"] = None,
+            logarithmic: Optional["scout_compute_api_LogarithmicCurve"] = None,
+            polynomial: Optional["scout_compute_api_PolynomialCurve"] = None,
+            power: Optional["scout_compute_api_PowerCurve"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (exponential is not None) + (logarithmic is not None) + (polynomial is not None) + (power is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if exponential is not None:
+                self._exponential = exponential
+                self._type = 'exponential'
+            if logarithmic is not None:
+                self._logarithmic = logarithmic
+                self._type = 'logarithmic'
+            if polynomial is not None:
+                self._polynomial = polynomial
+                self._type = 'polynomial'
+            if power is not None:
+                self._power = power
+                self._type = 'power'
+
+        elif type_of_union == 'exponential':
+            if exponential is None:
+                raise ValueError('a union value must not be None')
+            self._exponential = exponential
+            self._type = 'exponential'
+        elif type_of_union == 'logarithmic':
+            if logarithmic is None:
+                raise ValueError('a union value must not be None')
+            self._logarithmic = logarithmic
+            self._type = 'logarithmic'
+        elif type_of_union == 'polynomial':
+            if polynomial is None:
+                raise ValueError('a union value must not be None')
+            self._polynomial = polynomial
+            self._type = 'polynomial'
+        elif type_of_union == 'power':
+            if power is None:
+                raise ValueError('a union value must not be None')
+            self._power = power
+            self._type = 'power'
+
+    @builtins.property
+    def exponential(self) -> Optional["scout_compute_api_ExponentialCurve"]:
+        return self._exponential
+
+    @builtins.property
+    def logarithmic(self) -> Optional["scout_compute_api_LogarithmicCurve"]:
+        return self._logarithmic
+
+    @builtins.property
+    def polynomial(self) -> Optional["scout_compute_api_PolynomialCurve"]:
+        return self._polynomial
+
+    @builtins.property
+    def power(self) -> Optional["scout_compute_api_PowerCurve"]:
+        return self._power
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_compute_api_CurveFitDetailsVisitor):
+            raise ValueError('{} is not an instance of scout_compute_api_CurveFitDetailsVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'exponential' and self.exponential is not None:
+            return visitor._exponential(self.exponential)
+        if self._type == 'logarithmic' and self.logarithmic is not None:
+            return visitor._logarithmic(self.logarithmic)
+        if self._type == 'polynomial' and self.polynomial is not None:
+            return visitor._polynomial(self.polynomial)
+        if self._type == 'power' and self.power is not None:
+            return visitor._power(self.power)
+
+
+scout_compute_api_CurveFitDetails.__name__ = "CurveFitDetails"
+scout_compute_api_CurveFitDetails.__qualname__ = "CurveFitDetails"
+scout_compute_api_CurveFitDetails.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_CurveFitDetailsVisitor:
+
+    @abstractmethod
+    def _exponential(self, exponential: "scout_compute_api_ExponentialCurve") -> Any:
+        pass
+
+    @abstractmethod
+    def _logarithmic(self, logarithmic: "scout_compute_api_LogarithmicCurve") -> Any:
+        pass
+
+    @abstractmethod
+    def _polynomial(self, polynomial: "scout_compute_api_PolynomialCurve") -> Any:
+        pass
+
+    @abstractmethod
+    def _power(self, power: "scout_compute_api_PowerCurve") -> Any:
+        pass
+
+
+scout_compute_api_CurveFitDetailsVisitor.__name__ = "CurveFitDetailsVisitor"
+scout_compute_api_CurveFitDetailsVisitor.__qualname__ = "CurveFitDetailsVisitor"
+scout_compute_api_CurveFitDetailsVisitor.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_CurveFitOptions(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+        }
+
+    __slots__: List[str] = []
+
+
+
+scout_compute_api_CurveFitOptions.__name__ = "CurveFitOptions"
+scout_compute_api_CurveFitOptions.__qualname__ = "CurveFitOptions"
+scout_compute_api_CurveFitOptions.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_CurveFitPlotType(ConjureUnionType):
+    _time_series: Optional["scout_compute_api_TimeSeriesCurveFit"] = None
+    _scatter: Optional["scout_compute_api_ScatterCurveFit"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'time_series': ConjureFieldDefinition('timeSeries', scout_compute_api_TimeSeriesCurveFit),
+            'scatter': ConjureFieldDefinition('scatter', scout_compute_api_ScatterCurveFit)
+        }
+
+    def __init__(
+            self,
+            time_series: Optional["scout_compute_api_TimeSeriesCurveFit"] = None,
+            scatter: Optional["scout_compute_api_ScatterCurveFit"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (time_series is not None) + (scatter is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if time_series is not None:
+                self._time_series = time_series
+                self._type = 'timeSeries'
+            if scatter is not None:
+                self._scatter = scatter
+                self._type = 'scatter'
+
+        elif type_of_union == 'timeSeries':
+            if time_series is None:
+                raise ValueError('a union value must not be None')
+            self._time_series = time_series
+            self._type = 'timeSeries'
+        elif type_of_union == 'scatter':
+            if scatter is None:
+                raise ValueError('a union value must not be None')
+            self._scatter = scatter
+            self._type = 'scatter'
+
+    @builtins.property
+    def time_series(self) -> Optional["scout_compute_api_TimeSeriesCurveFit"]:
+        return self._time_series
+
+    @builtins.property
+    def scatter(self) -> Optional["scout_compute_api_ScatterCurveFit"]:
+        return self._scatter
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_compute_api_CurveFitPlotTypeVisitor):
+            raise ValueError('{} is not an instance of scout_compute_api_CurveFitPlotTypeVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'timeSeries' and self.time_series is not None:
+            return visitor._time_series(self.time_series)
+        if self._type == 'scatter' and self.scatter is not None:
+            return visitor._scatter(self.scatter)
+
+
+scout_compute_api_CurveFitPlotType.__name__ = "CurveFitPlotType"
+scout_compute_api_CurveFitPlotType.__qualname__ = "CurveFitPlotType"
+scout_compute_api_CurveFitPlotType.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_CurveFitPlotTypeVisitor:
+
+    @abstractmethod
+    def _time_series(self, time_series: "scout_compute_api_TimeSeriesCurveFit") -> Any:
+        pass
+
+    @abstractmethod
+    def _scatter(self, scatter: "scout_compute_api_ScatterCurveFit") -> Any:
+        pass
+
+
+scout_compute_api_CurveFitPlotTypeVisitor.__name__ = "CurveFitPlotTypeVisitor"
+scout_compute_api_CurveFitPlotTypeVisitor.__qualname__ = "CurveFitPlotTypeVisitor"
+scout_compute_api_CurveFitPlotTypeVisitor.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_CurveFitResult(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'r2': ConjureFieldDefinition('r2', float),
+            'curve_result_details': ConjureFieldDefinition('curveResultDetails', scout_compute_api_CurveResultDetails)
+        }
+
+    __slots__: List[str] = ['_r2', '_curve_result_details']
+
+    def __init__(self, curve_result_details: "scout_compute_api_CurveResultDetails", r2: float) -> None:
+        self._r2 = r2
+        self._curve_result_details = curve_result_details
+
+    @builtins.property
+    def r2(self) -> float:
+        """
+        R^2 (coefficient of determination) for the fit curve, a normalized measure of how well the curve fits the data.
+Usually ranges from 0 to 1, with higher indicating better fit (points closer to fit line).
+        """
+        return self._r2
+
+    @builtins.property
+    def curve_result_details(self) -> "scout_compute_api_CurveResultDetails":
+        """
+        Description of the fit curve.
+        """
+        return self._curve_result_details
+
+
+scout_compute_api_CurveFitResult.__name__ = "CurveFitResult"
+scout_compute_api_CurveFitResult.__qualname__ = "CurveFitResult"
+scout_compute_api_CurveFitResult.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_CurveResultDetails(ConjureUnionType):
+    _exponential: Optional["scout_compute_api_ExponentialResultDetails"] = None
+    _logarithmic: Optional["scout_compute_api_LogarithmicResultDetails"] = None
+    _polynomial: Optional["scout_compute_api_PolynomialResultDetails"] = None
+    _power: Optional["scout_compute_api_PowerResultDetails"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'exponential': ConjureFieldDefinition('exponential', scout_compute_api_ExponentialResultDetails),
+            'logarithmic': ConjureFieldDefinition('logarithmic', scout_compute_api_LogarithmicResultDetails),
+            'polynomial': ConjureFieldDefinition('polynomial', scout_compute_api_PolynomialResultDetails),
+            'power': ConjureFieldDefinition('power', scout_compute_api_PowerResultDetails)
+        }
+
+    def __init__(
+            self,
+            exponential: Optional["scout_compute_api_ExponentialResultDetails"] = None,
+            logarithmic: Optional["scout_compute_api_LogarithmicResultDetails"] = None,
+            polynomial: Optional["scout_compute_api_PolynomialResultDetails"] = None,
+            power: Optional["scout_compute_api_PowerResultDetails"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (exponential is not None) + (logarithmic is not None) + (polynomial is not None) + (power is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if exponential is not None:
+                self._exponential = exponential
+                self._type = 'exponential'
+            if logarithmic is not None:
+                self._logarithmic = logarithmic
+                self._type = 'logarithmic'
+            if polynomial is not None:
+                self._polynomial = polynomial
+                self._type = 'polynomial'
+            if power is not None:
+                self._power = power
+                self._type = 'power'
+
+        elif type_of_union == 'exponential':
+            if exponential is None:
+                raise ValueError('a union value must not be None')
+            self._exponential = exponential
+            self._type = 'exponential'
+        elif type_of_union == 'logarithmic':
+            if logarithmic is None:
+                raise ValueError('a union value must not be None')
+            self._logarithmic = logarithmic
+            self._type = 'logarithmic'
+        elif type_of_union == 'polynomial':
+            if polynomial is None:
+                raise ValueError('a union value must not be None')
+            self._polynomial = polynomial
+            self._type = 'polynomial'
+        elif type_of_union == 'power':
+            if power is None:
+                raise ValueError('a union value must not be None')
+            self._power = power
+            self._type = 'power'
+
+    @builtins.property
+    def exponential(self) -> Optional["scout_compute_api_ExponentialResultDetails"]:
+        return self._exponential
+
+    @builtins.property
+    def logarithmic(self) -> Optional["scout_compute_api_LogarithmicResultDetails"]:
+        return self._logarithmic
+
+    @builtins.property
+    def polynomial(self) -> Optional["scout_compute_api_PolynomialResultDetails"]:
+        return self._polynomial
+
+    @builtins.property
+    def power(self) -> Optional["scout_compute_api_PowerResultDetails"]:
+        return self._power
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_compute_api_CurveResultDetailsVisitor):
+            raise ValueError('{} is not an instance of scout_compute_api_CurveResultDetailsVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'exponential' and self.exponential is not None:
+            return visitor._exponential(self.exponential)
+        if self._type == 'logarithmic' and self.logarithmic is not None:
+            return visitor._logarithmic(self.logarithmic)
+        if self._type == 'polynomial' and self.polynomial is not None:
+            return visitor._polynomial(self.polynomial)
+        if self._type == 'power' and self.power is not None:
+            return visitor._power(self.power)
+
+
+scout_compute_api_CurveResultDetails.__name__ = "CurveResultDetails"
+scout_compute_api_CurveResultDetails.__qualname__ = "CurveResultDetails"
+scout_compute_api_CurveResultDetails.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_CurveResultDetailsVisitor:
+
+    @abstractmethod
+    def _exponential(self, exponential: "scout_compute_api_ExponentialResultDetails") -> Any:
+        pass
+
+    @abstractmethod
+    def _logarithmic(self, logarithmic: "scout_compute_api_LogarithmicResultDetails") -> Any:
+        pass
+
+    @abstractmethod
+    def _polynomial(self, polynomial: "scout_compute_api_PolynomialResultDetails") -> Any:
+        pass
+
+    @abstractmethod
+    def _power(self, power: "scout_compute_api_PowerResultDetails") -> Any:
+        pass
+
+
+scout_compute_api_CurveResultDetailsVisitor.__name__ = "CurveResultDetailsVisitor"
+scout_compute_api_CurveResultDetailsVisitor.__qualname__ = "CurveResultDetailsVisitor"
+scout_compute_api_CurveResultDetailsVisitor.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_DataSourceChannel(ConjureBeanType):
 
     @builtins.classmethod
@@ -35608,6 +36053,7 @@ class scout_compute_api_EnumSeries(ConjureUnionType):
     _time_shift: Optional["scout_compute_api_EnumTimeShiftSeries"] = None
     _union: Optional["scout_compute_api_EnumUnionSeries"] = None
     _filter_transformation: Optional["scout_compute_api_EnumFilterTransformationSeries"] = None
+    _value_map: Optional["scout_compute_api_ValueMapSeries"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
@@ -35620,7 +36066,8 @@ class scout_compute_api_EnumSeries(ConjureUnionType):
             'time_range_filter': ConjureFieldDefinition('timeRangeFilter', scout_compute_api_EnumTimeRangeFilterSeries),
             'time_shift': ConjureFieldDefinition('timeShift', scout_compute_api_EnumTimeShiftSeries),
             'union': ConjureFieldDefinition('union', scout_compute_api_EnumUnionSeries),
-            'filter_transformation': ConjureFieldDefinition('filterTransformation', scout_compute_api_EnumFilterTransformationSeries)
+            'filter_transformation': ConjureFieldDefinition('filterTransformation', scout_compute_api_EnumFilterTransformationSeries),
+            'value_map': ConjureFieldDefinition('valueMap', scout_compute_api_ValueMapSeries)
         }
 
     def __init__(
@@ -35634,10 +36081,11 @@ class scout_compute_api_EnumSeries(ConjureUnionType):
             time_shift: Optional["scout_compute_api_EnumTimeShiftSeries"] = None,
             union: Optional["scout_compute_api_EnumUnionSeries"] = None,
             filter_transformation: Optional["scout_compute_api_EnumFilterTransformationSeries"] = None,
+            value_map: Optional["scout_compute_api_ValueMapSeries"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (aggregate is not None) + (function is not None) + (raw is not None) + (channel is not None) + (resample is not None) + (time_range_filter is not None) + (time_shift is not None) + (union is not None) + (filter_transformation is not None) != 1:
+            if (aggregate is not None) + (function is not None) + (raw is not None) + (channel is not None) + (resample is not None) + (time_range_filter is not None) + (time_shift is not None) + (union is not None) + (filter_transformation is not None) + (value_map is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if aggregate is not None:
@@ -35667,6 +36115,9 @@ class scout_compute_api_EnumSeries(ConjureUnionType):
             if filter_transformation is not None:
                 self._filter_transformation = filter_transformation
                 self._type = 'filterTransformation'
+            if value_map is not None:
+                self._value_map = value_map
+                self._type = 'valueMap'
 
         elif type_of_union == 'aggregate':
             if aggregate is None:
@@ -35713,6 +36164,11 @@ class scout_compute_api_EnumSeries(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._filter_transformation = filter_transformation
             self._type = 'filterTransformation'
+        elif type_of_union == 'valueMap':
+            if value_map is None:
+                raise ValueError('a union value must not be None')
+            self._value_map = value_map
+            self._type = 'valueMap'
 
     @builtins.property
     def aggregate(self) -> Optional["scout_compute_api_AggregateEnumSeries"]:
@@ -35750,6 +36206,10 @@ class scout_compute_api_EnumSeries(ConjureUnionType):
     def filter_transformation(self) -> Optional["scout_compute_api_EnumFilterTransformationSeries"]:
         return self._filter_transformation
 
+    @builtins.property
+    def value_map(self) -> Optional["scout_compute_api_ValueMapSeries"]:
+        return self._value_map
+
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, scout_compute_api_EnumSeriesVisitor):
             raise ValueError('{} is not an instance of scout_compute_api_EnumSeriesVisitor'.format(visitor.__class__.__name__))
@@ -35771,6 +36231,8 @@ class scout_compute_api_EnumSeries(ConjureUnionType):
             return visitor._union(self.union)
         if self._type == 'filterTransformation' and self.filter_transformation is not None:
             return visitor._filter_transformation(self.filter_transformation)
+        if self._type == 'valueMap' and self.value_map is not None:
+            return visitor._value_map(self.value_map)
 
 
 scout_compute_api_EnumSeries.__name__ = "EnumSeries"
@@ -35816,6 +36278,10 @@ class scout_compute_api_EnumSeriesVisitor:
     def _filter_transformation(self, filter_transformation: "scout_compute_api_EnumFilterTransformationSeries") -> Any:
         pass
 
+    @abstractmethod
+    def _value_map(self, value_map: "scout_compute_api_ValueMapSeries") -> Any:
+        pass
+
 
 scout_compute_api_EnumSeriesVisitor.__name__ = "EnumSeriesVisitor"
 scout_compute_api_EnumSeriesVisitor.__qualname__ = "EnumSeriesVisitor"
@@ -36099,6 +36565,64 @@ scout_compute_api_ExcludeNegativeValues.__qualname__ = "ExcludeNegativeValues"
 scout_compute_api_ExcludeNegativeValues.__module__ = "nominal_api.scout_compute_api"
 
 
+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
+
+    @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"
+scout_compute_api_ExponentialCurve.__qualname__ = "ExponentialCurve"
+scout_compute_api_ExponentialCurve.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_ExponentialResultDetails(ConjureBeanType):
+    """
+    y = a * e^(b * x)
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'a': ConjureFieldDefinition('a', float),
+            'b': ConjureFieldDefinition('b', float)
+        }
+
+    __slots__: List[str] = ['_a', '_b']
+
+    def __init__(self, a: float, b: float) -> None:
+        self._a = a
+        self._b = b
+
+    @builtins.property
+    def a(self) -> float:
+        return self._a
+
+    @builtins.property
+    def b(self) -> float:
+        return self._b
+
+
+scout_compute_api_ExponentialResultDetails.__name__ = "ExponentialResultDetails"
+scout_compute_api_ExponentialResultDetails.__qualname__ = "ExponentialResultDetails"
+scout_compute_api_ExponentialResultDetails.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_Fft(ConjureBeanType):
     """
     Returns the single sided amplitude spectrum of the input series.
@@ -37544,6 +38068,54 @@ scout_compute_api_LogValue.__qualname__ = "LogValue"
 scout_compute_api_LogValue.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_LogarithmicCurve(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+        }
+
+    __slots__: List[str] = []
+
+
+
+scout_compute_api_LogarithmicCurve.__name__ = "LogarithmicCurve"
+scout_compute_api_LogarithmicCurve.__qualname__ = "LogarithmicCurve"
+scout_compute_api_LogarithmicCurve.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_LogarithmicResultDetails(ConjureBeanType):
+    """
+    y = a * ln(x) + b
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'a': ConjureFieldDefinition('a', float),
+            'b': ConjureFieldDefinition('b', float)
+        }
+
+    __slots__: List[str] = ['_a', '_b']
+
+    def __init__(self, a: float, b: float) -> None:
+        self._a = a
+        self._b = b
+
+    @builtins.property
+    def a(self) -> float:
+        return self._a
+
+    @builtins.property
+    def b(self) -> float:
+        return self._b
+
+
+scout_compute_api_LogarithmicResultDetails.__name__ = "LogarithmicResultDetails"
+scout_compute_api_LogarithmicResultDetails.__qualname__ = "LogarithmicResultDetails"
+scout_compute_api_LogarithmicResultDetails.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_LowPassConfiguration(ConjureBeanType):
 
     @builtins.classmethod
@@ -39972,6 +40544,115 @@ scout_compute_api_Point3d.__qualname__ = "Point3d"
 scout_compute_api_Point3d.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_PolynomialCurve(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'degree': ConjureFieldDefinition('degree', scout_compute_api_IntegerConstant),
+            'intercept': ConjureFieldDefinition('intercept', OptionalTypeWrapper[scout_compute_api_DoubleConstant])
+        }
+
+    __slots__: List[str] = ['_degree', '_intercept']
+
+    def __init__(self, degree: "scout_compute_api_IntegerConstant", intercept: Optional["scout_compute_api_DoubleConstant"] = None) -> None:
+        self._degree = degree
+        self._intercept = intercept
+
+    @builtins.property
+    def degree(self) -> "scout_compute_api_IntegerConstant":
+        """
+        The highest allowable degree of the fit polynomial.
+        """
+        return self._degree
+
+    @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_PolynomialCurve.__name__ = "PolynomialCurve"
+scout_compute_api_PolynomialCurve.__qualname__ = "PolynomialCurve"
+scout_compute_api_PolynomialCurve.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_PolynomialResultDetails(ConjureBeanType):
+    """
+    y = sum( a_i * x^i ) for i in 0...len(a)
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'a': ConjureFieldDefinition('a', List[float])
+        }
+
+    __slots__: List[str] = ['_a']
+
+    def __init__(self, a: List[float]) -> None:
+        self._a = a
+
+    @builtins.property
+    def a(self) -> List[float]:
+        return self._a
+
+
+scout_compute_api_PolynomialResultDetails.__name__ = "PolynomialResultDetails"
+scout_compute_api_PolynomialResultDetails.__qualname__ = "PolynomialResultDetails"
+scout_compute_api_PolynomialResultDetails.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_PowerCurve(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+        }
+
+    __slots__: List[str] = []
+
+
+
+scout_compute_api_PowerCurve.__name__ = "PowerCurve"
+scout_compute_api_PowerCurve.__qualname__ = "PowerCurve"
+scout_compute_api_PowerCurve.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_PowerResultDetails(ConjureBeanType):
+    """
+    y = a * x^b
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'a': ConjureFieldDefinition('a', float),
+            'b': ConjureFieldDefinition('b', float)
+        }
+
+    __slots__: List[str] = ['_a', '_b']
+
+    def __init__(self, a: float, b: float) -> None:
+        self._a = a
+        self._b = b
+
+    @builtins.property
+    def a(self) -> float:
+        return self._a
+
+    @builtins.property
+    def b(self) -> float:
+        return self._b
+
+
+scout_compute_api_PowerResultDetails.__name__ = "PowerResultDetails"
+scout_compute_api_PowerResultDetails.__qualname__ = "PowerResultDetails"
+scout_compute_api_PowerResultDetails.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_ProductSeries(ConjureBeanType):
     """
     For every timestamp specified in the input series, outputs a value that is the product for that timestamp
@@ -40230,6 +40911,50 @@ scout_compute_api_RangeAggregationOperationVisitor.__qualname__ = "RangeAggregat
 scout_compute_api_RangeAggregationOperationVisitor.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_RangeMap(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'start': ConjureFieldDefinition('start', OptionalTypeWrapper[scout_compute_api_DoubleConstant]),
+            'end': ConjureFieldDefinition('end', OptionalTypeWrapper[scout_compute_api_DoubleConstant]),
+            'output': ConjureFieldDefinition('output', scout_compute_api_StringConstant)
+        }
+
+    __slots__: List[str] = ['_start', '_end', '_output']
+
+    def __init__(self, output: "scout_compute_api_StringConstant", end: Optional["scout_compute_api_DoubleConstant"] = None, start: Optional["scout_compute_api_DoubleConstant"] = None) -> None:
+        self._start = start
+        self._end = end
+        self._output = output
+
+    @builtins.property
+    def start(self) -> Optional["scout_compute_api_DoubleConstant"]:
+        """
+        Inclusive start value. If not specified, the start is the prior range's end value, or negative infinity.
+        """
+        return self._start
+
+    @builtins.property
+    def end(self) -> Optional["scout_compute_api_DoubleConstant"]:
+        """
+        Exclusive end value. If not specified, the end value is the next range's start value, or positive infinity.
+        """
+        return self._end
+
+    @builtins.property
+    def output(self) -> "scout_compute_api_StringConstant":
+        """
+        The value to map to if the input value is within the range.
+        """
+        return self._output
+
+
+scout_compute_api_RangeMap.__name__ = "RangeMap"
+scout_compute_api_RangeMap.__qualname__ = "RangeMap"
+scout_compute_api_RangeMap.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_RangeSeries(ConjureUnionType):
     _approximate_threshold: Optional["scout_compute_api_ApproximateThresholdRanges"] = None
     _enum_filter: Optional["scout_compute_api_EnumFilterRanges"] = None
@@ -41271,6 +41996,10 @@ scout_compute_api_ScaleSeries.__module__ = "nominal_api.scout_compute_api"
 
 
 class scout_compute_api_Scatter(ConjureBeanType):
+    """
+    A scatter plot comprised of the values from one input series on the x-axis
+and values from another input series on the y-axis, for all points within a requested time range.
+    """
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
@@ -41340,6 +42069,98 @@ scout_compute_api_Scatter3d.__qualname__ = "Scatter3d"
 scout_compute_api_Scatter3d.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_ScatterCurveFit(ConjureBeanType):
+    """
+    Fits a curve to the scatter between two series.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'scatter': ConjureFieldDefinition('scatter', scout_compute_api_Scatter),
+            'options': ConjureFieldDefinition('options', scout_compute_api_ScatterFitOptions)
+        }
+
+    __slots__: List[str] = ['_scatter', '_options']
+
+    def __init__(self, options: "scout_compute_api_ScatterFitOptions", scatter: "scout_compute_api_Scatter") -> None:
+        self._scatter = scatter
+        self._options = options
+
+    @builtins.property
+    def scatter(self) -> "scout_compute_api_Scatter":
+        """
+        The x and y series to fit to.
+        """
+        return self._scatter
+
+    @builtins.property
+    def options(self) -> "scout_compute_api_ScatterFitOptions":
+        return self._options
+
+
+scout_compute_api_ScatterCurveFit.__name__ = "ScatterCurveFit"
+scout_compute_api_ScatterCurveFit.__qualname__ = "ScatterCurveFit"
+scout_compute_api_ScatterCurveFit.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_ScatterFitOptions(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'min_x': ConjureFieldDefinition('minX', OptionalTypeWrapper[scout_compute_api_DoubleConstant]),
+            'max_x': ConjureFieldDefinition('maxX', OptionalTypeWrapper[scout_compute_api_DoubleConstant]),
+            'min_y': ConjureFieldDefinition('minY', OptionalTypeWrapper[scout_compute_api_DoubleConstant]),
+            'max_y': ConjureFieldDefinition('maxY', OptionalTypeWrapper[scout_compute_api_DoubleConstant])
+        }
+
+    __slots__: List[str] = ['_min_x', '_max_x', '_min_y', '_max_y']
+
+    def __init__(self, max_x: Optional["scout_compute_api_DoubleConstant"] = None, max_y: Optional["scout_compute_api_DoubleConstant"] = None, min_x: Optional["scout_compute_api_DoubleConstant"] = None, min_y: Optional["scout_compute_api_DoubleConstant"] = None) -> None:
+        self._min_x = min_x
+        self._max_x = max_x
+        self._min_y = min_y
+        self._max_y = max_y
+
+    @builtins.property
+    def min_x(self) -> Optional["scout_compute_api_DoubleConstant"]:
+        """
+        Inclusive lower bound on the x values to fit to. If omitted, does not set a bound
+(equivalent to setting this to the minimum x value among all points in the time range).
+        """
+        return self._min_x
+
+    @builtins.property
+    def max_x(self) -> Optional["scout_compute_api_DoubleConstant"]:
+        """
+        Inclusive upper bound on the x values to fit to. If omitted, does not set a bound
+(equivalent to setting this to the maximum x value among all points in the time range).
+        """
+        return self._max_x
+
+    @builtins.property
+    def min_y(self) -> Optional["scout_compute_api_DoubleConstant"]:
+        """
+        Inclusive lower bound on the y values to fit to. If omitted, does not set a bound
+(equivalent to setting this to the minimum y value among all points in the time range).
+        """
+        return self._min_y
+
+    @builtins.property
+    def max_y(self) -> Optional["scout_compute_api_DoubleConstant"]:
+        """
+        Inclusive upper bound on the y values to fit to. If omitted, does not set a bound
+(equivalent to setting this to the maximum y value among all points in the time range).
+        """
+        return self._max_y
+
+
+scout_compute_api_ScatterFitOptions.__name__ = "ScatterFitOptions"
+scout_compute_api_ScatterFitOptions.__qualname__ = "ScatterFitOptions"
+scout_compute_api_ScatterFitOptions.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_ScatterSummarizationStrategy(ConjureUnionType):
     _spatial: Optional["scout_compute_api_SpatialDecimateStrategy"] = None
 
@@ -42809,6 +43630,68 @@ scout_compute_api_TimeDifferenceSeries.__qualname__ = "TimeDifferenceSeries"
 scout_compute_api_TimeDifferenceSeries.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_TimeSeriesCurveFit(ConjureBeanType):
+    """
+    Fits a curve to a series vs its timestamps.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'series': ConjureFieldDefinition('series', scout_compute_api_NumericSeries),
+            'options': ConjureFieldDefinition('options', scout_compute_api_TimeSeriesFitOptions)
+        }
+
+    __slots__: List[str] = ['_series', '_options']
+
+    def __init__(self, options: "scout_compute_api_TimeSeriesFitOptions", series: "scout_compute_api_NumericSeries") -> None:
+        self._series = series
+        self._options = options
+
+    @builtins.property
+    def series(self) -> "scout_compute_api_NumericSeries":
+        """
+        The series to fit. Timestamps will be used as x values and data as y values. The leftmost (earliest)
+timestamp will be used as the value of 0, and all other timestamps will be relative to that.
+        """
+        return self._series
+
+    @builtins.property
+    def options(self) -> "scout_compute_api_TimeSeriesFitOptions":
+        return self._options
+
+
+scout_compute_api_TimeSeriesCurveFit.__name__ = "TimeSeriesCurveFit"
+scout_compute_api_TimeSeriesCurveFit.__qualname__ = "TimeSeriesCurveFit"
+scout_compute_api_TimeSeriesCurveFit.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_TimeSeriesFitOptions(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'time_unit': ConjureFieldDefinition('timeUnit', OptionalTypeWrapper[api_TimeUnit])
+        }
+
+    __slots__: List[str] = ['_time_unit']
+
+    def __init__(self, time_unit: Optional["api_TimeUnit"] = None) -> None:
+        self._time_unit = time_unit
+
+    @builtins.property
+    def time_unit(self) -> Optional["api_TimeUnit"]:
+        """
+        Time unit used for the timestamps to fit against. Defaults to seconds if not specified.
+        """
+        return self._time_unit
+
+
+scout_compute_api_TimeSeriesFitOptions.__name__ = "TimeSeriesFitOptions"
+scout_compute_api_TimeSeriesFitOptions.__qualname__ = "TimeSeriesFitOptions"
+scout_compute_api_TimeSeriesFitOptions.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_TimestampAndId(ConjureBeanType):
 
     @builtins.classmethod
@@ -43312,6 +44195,55 @@ scout_compute_api_ValueDifferenceSeries.__qualname__ = "ValueDifferenceSeries"
 scout_compute_api_ValueDifferenceSeries.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_ValueMapSeries(ConjureBeanType):
+    """
+    Maps a continuous numeric series to a discrete enum series using the specified value ranges.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'input': ConjureFieldDefinition('input', scout_compute_api_NumericSeries),
+            'mapping': ConjureFieldDefinition('mapping', List[scout_compute_api_RangeMap]),
+            'fallback': ConjureFieldDefinition('fallback', OptionalTypeWrapper[scout_compute_api_StringConstant])
+        }
+
+    __slots__: List[str] = ['_input', '_mapping', '_fallback']
+
+    def __init__(self, input: "scout_compute_api_NumericSeries", mapping: List["scout_compute_api_RangeMap"], fallback: Optional["scout_compute_api_StringConstant"] = None) -> None:
+        self._input = input
+        self._mapping = mapping
+        self._fallback = fallback
+
+    @builtins.property
+    def input(self) -> "scout_compute_api_NumericSeries":
+        """
+        The input series to map to an enumerated series
+        """
+        return self._input
+
+    @builtins.property
+    def mapping(self) -> List["scout_compute_api_RangeMap"]:
+        """
+        The output of the first capturing range will be used. Ranges are start inclusive, end exclusive, must not overlap,
+and increasing from lowest to highest. Ranges can be open ended to the edge of the next or prior range.
+The first range can be open ended to negative infinity, and the last range can be open ended to positive infinity.
+        """
+        return self._mapping
+
+    @builtins.property
+    def fallback(self) -> Optional["scout_compute_api_StringConstant"]:
+        """
+        The fallback value if not captured by any range. If not specified, points will be filtered.
+        """
+        return self._fallback
+
+
+scout_compute_api_ValueMapSeries.__name__ = "ValueMapSeries"
+scout_compute_api_ValueMapSeries.__qualname__ = "ValueMapSeries"
+scout_compute_api_ValueMapSeries.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_VariableValue(ConjureUnionType):
     _double: Optional[float] = None
     _compute_node: Optional["scout_compute_api_ComputeNodeWithContext"] = None
@@ -47038,6 +47970,253 @@ scout_compute_resolved_api_CumulativeSumSeriesNode.__qualname__ = "CumulativeSum
 scout_compute_resolved_api_CumulativeSumSeriesNode.__module__ = "nominal_api.scout_compute_resolved_api"
 
 
+class scout_compute_resolved_api_CurveFitDetails(ConjureUnionType):
+    _exponential: Optional["scout_compute_resolved_api_ExponentialCurve"] = None
+    _logarithmic: Optional["scout_compute_resolved_api_LogarithmicCurve"] = None
+    _polynomial: Optional["scout_compute_resolved_api_PolynomialCurve"] = None
+    _power: Optional["scout_compute_resolved_api_PowerCurve"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'exponential': ConjureFieldDefinition('exponential', scout_compute_resolved_api_ExponentialCurve),
+            'logarithmic': ConjureFieldDefinition('logarithmic', scout_compute_resolved_api_LogarithmicCurve),
+            'polynomial': ConjureFieldDefinition('polynomial', scout_compute_resolved_api_PolynomialCurve),
+            'power': ConjureFieldDefinition('power', scout_compute_resolved_api_PowerCurve)
+        }
+
+    def __init__(
+            self,
+            exponential: Optional["scout_compute_resolved_api_ExponentialCurve"] = None,
+            logarithmic: Optional["scout_compute_resolved_api_LogarithmicCurve"] = None,
+            polynomial: Optional["scout_compute_resolved_api_PolynomialCurve"] = None,
+            power: Optional["scout_compute_resolved_api_PowerCurve"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (exponential is not None) + (logarithmic is not None) + (polynomial is not None) + (power is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if exponential is not None:
+                self._exponential = exponential
+                self._type = 'exponential'
+            if logarithmic is not None:
+                self._logarithmic = logarithmic
+                self._type = 'logarithmic'
+            if polynomial is not None:
+                self._polynomial = polynomial
+                self._type = 'polynomial'
+            if power is not None:
+                self._power = power
+                self._type = 'power'
+
+        elif type_of_union == 'exponential':
+            if exponential is None:
+                raise ValueError('a union value must not be None')
+            self._exponential = exponential
+            self._type = 'exponential'
+        elif type_of_union == 'logarithmic':
+            if logarithmic is None:
+                raise ValueError('a union value must not be None')
+            self._logarithmic = logarithmic
+            self._type = 'logarithmic'
+        elif type_of_union == 'polynomial':
+            if polynomial is None:
+                raise ValueError('a union value must not be None')
+            self._polynomial = polynomial
+            self._type = 'polynomial'
+        elif type_of_union == 'power':
+            if power is None:
+                raise ValueError('a union value must not be None')
+            self._power = power
+            self._type = 'power'
+
+    @builtins.property
+    def exponential(self) -> Optional["scout_compute_resolved_api_ExponentialCurve"]:
+        return self._exponential
+
+    @builtins.property
+    def logarithmic(self) -> Optional["scout_compute_resolved_api_LogarithmicCurve"]:
+        return self._logarithmic
+
+    @builtins.property
+    def polynomial(self) -> Optional["scout_compute_resolved_api_PolynomialCurve"]:
+        return self._polynomial
+
+    @builtins.property
+    def power(self) -> Optional["scout_compute_resolved_api_PowerCurve"]:
+        return self._power
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_compute_resolved_api_CurveFitDetailsVisitor):
+            raise ValueError('{} is not an instance of scout_compute_resolved_api_CurveFitDetailsVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'exponential' and self.exponential is not None:
+            return visitor._exponential(self.exponential)
+        if self._type == 'logarithmic' and self.logarithmic is not None:
+            return visitor._logarithmic(self.logarithmic)
+        if self._type == 'polynomial' and self.polynomial is not None:
+            return visitor._polynomial(self.polynomial)
+        if self._type == 'power' and self.power is not None:
+            return visitor._power(self.power)
+
+
+scout_compute_resolved_api_CurveFitDetails.__name__ = "CurveFitDetails"
+scout_compute_resolved_api_CurveFitDetails.__qualname__ = "CurveFitDetails"
+scout_compute_resolved_api_CurveFitDetails.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
+class scout_compute_resolved_api_CurveFitDetailsVisitor:
+
+    @abstractmethod
+    def _exponential(self, exponential: "scout_compute_resolved_api_ExponentialCurve") -> Any:
+        pass
+
+    @abstractmethod
+    def _logarithmic(self, logarithmic: "scout_compute_resolved_api_LogarithmicCurve") -> Any:
+        pass
+
+    @abstractmethod
+    def _polynomial(self, polynomial: "scout_compute_resolved_api_PolynomialCurve") -> Any:
+        pass
+
+    @abstractmethod
+    def _power(self, power: "scout_compute_resolved_api_PowerCurve") -> Any:
+        pass
+
+
+scout_compute_resolved_api_CurveFitDetailsVisitor.__name__ = "CurveFitDetailsVisitor"
+scout_compute_resolved_api_CurveFitDetailsVisitor.__qualname__ = "CurveFitDetailsVisitor"
+scout_compute_resolved_api_CurveFitDetailsVisitor.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
+class scout_compute_resolved_api_CurveFitNode(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'curve_fit_plot_type': ConjureFieldDefinition('curveFitPlotType', scout_compute_resolved_api_CurveFitPlotTypeNode),
+            'curve_fit_details': ConjureFieldDefinition('curveFitDetails', scout_compute_resolved_api_CurveFitDetails),
+            'curve_fit_options': ConjureFieldDefinition('curveFitOptions', scout_compute_resolved_api_CurveFitOptions)
+        }
+
+    __slots__: List[str] = ['_curve_fit_plot_type', '_curve_fit_details', '_curve_fit_options']
+
+    def __init__(self, curve_fit_details: "scout_compute_resolved_api_CurveFitDetails", curve_fit_options: "scout_compute_resolved_api_CurveFitOptions", curve_fit_plot_type: "scout_compute_resolved_api_CurveFitPlotTypeNode") -> None:
+        self._curve_fit_plot_type = curve_fit_plot_type
+        self._curve_fit_details = curve_fit_details
+        self._curve_fit_options = curve_fit_options
+
+    @builtins.property
+    def curve_fit_plot_type(self) -> "scout_compute_resolved_api_CurveFitPlotTypeNode":
+        return self._curve_fit_plot_type
+
+    @builtins.property
+    def curve_fit_details(self) -> "scout_compute_resolved_api_CurveFitDetails":
+        return self._curve_fit_details
+
+    @builtins.property
+    def curve_fit_options(self) -> "scout_compute_resolved_api_CurveFitOptions":
+        return self._curve_fit_options
+
+
+scout_compute_resolved_api_CurveFitNode.__name__ = "CurveFitNode"
+scout_compute_resolved_api_CurveFitNode.__qualname__ = "CurveFitNode"
+scout_compute_resolved_api_CurveFitNode.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
+class scout_compute_resolved_api_CurveFitOptions(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+        }
+
+    __slots__: List[str] = []
+
+
+
+scout_compute_resolved_api_CurveFitOptions.__name__ = "CurveFitOptions"
+scout_compute_resolved_api_CurveFitOptions.__qualname__ = "CurveFitOptions"
+scout_compute_resolved_api_CurveFitOptions.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
+class scout_compute_resolved_api_CurveFitPlotTypeNode(ConjureUnionType):
+    _time_series: Optional["scout_compute_resolved_api_TimeSeriesCurveFitNode"] = None
+    _scatter: Optional["scout_compute_resolved_api_ScatterCurveFitNode"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'time_series': ConjureFieldDefinition('timeSeries', scout_compute_resolved_api_TimeSeriesCurveFitNode),
+            'scatter': ConjureFieldDefinition('scatter', scout_compute_resolved_api_ScatterCurveFitNode)
+        }
+
+    def __init__(
+            self,
+            time_series: Optional["scout_compute_resolved_api_TimeSeriesCurveFitNode"] = None,
+            scatter: Optional["scout_compute_resolved_api_ScatterCurveFitNode"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (time_series is not None) + (scatter is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if time_series is not None:
+                self._time_series = time_series
+                self._type = 'timeSeries'
+            if scatter is not None:
+                self._scatter = scatter
+                self._type = 'scatter'
+
+        elif type_of_union == 'timeSeries':
+            if time_series is None:
+                raise ValueError('a union value must not be None')
+            self._time_series = time_series
+            self._type = 'timeSeries'
+        elif type_of_union == 'scatter':
+            if scatter is None:
+                raise ValueError('a union value must not be None')
+            self._scatter = scatter
+            self._type = 'scatter'
+
+    @builtins.property
+    def time_series(self) -> Optional["scout_compute_resolved_api_TimeSeriesCurveFitNode"]:
+        return self._time_series
+
+    @builtins.property
+    def scatter(self) -> Optional["scout_compute_resolved_api_ScatterCurveFitNode"]:
+        return self._scatter
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_compute_resolved_api_CurveFitPlotTypeNodeVisitor):
+            raise ValueError('{} is not an instance of scout_compute_resolved_api_CurveFitPlotTypeNodeVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'timeSeries' and self.time_series is not None:
+            return visitor._time_series(self.time_series)
+        if self._type == 'scatter' and self.scatter is not None:
+            return visitor._scatter(self.scatter)
+
+
+scout_compute_resolved_api_CurveFitPlotTypeNode.__name__ = "CurveFitPlotTypeNode"
+scout_compute_resolved_api_CurveFitPlotTypeNode.__qualname__ = "CurveFitPlotTypeNode"
+scout_compute_resolved_api_CurveFitPlotTypeNode.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
+class scout_compute_resolved_api_CurveFitPlotTypeNodeVisitor:
+
+    @abstractmethod
+    def _time_series(self, time_series: "scout_compute_resolved_api_TimeSeriesCurveFitNode") -> Any:
+        pass
+
+    @abstractmethod
+    def _scatter(self, scatter: "scout_compute_resolved_api_ScatterCurveFitNode") -> Any:
+        pass
+
+
+scout_compute_resolved_api_CurveFitPlotTypeNodeVisitor.__name__ = "CurveFitPlotTypeNodeVisitor"
+scout_compute_resolved_api_CurveFitPlotTypeNodeVisitor.__qualname__ = "CurveFitPlotTypeNodeVisitor"
+scout_compute_resolved_api_CurveFitPlotTypeNodeVisitor.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
 class scout_compute_resolved_api_DerivativeSeriesNode(ConjureBeanType):
 
     @builtins.classmethod
@@ -47270,6 +48449,7 @@ class scout_compute_resolved_api_EnumSeriesNode(ConjureUnionType):
     _union: Optional["scout_compute_resolved_api_EnumUnionSeriesNode"] = None
     _aggregate: Optional["scout_compute_resolved_api_AggregateEnumSeriesNode"] = None
     _filter_transformation: Optional["scout_compute_resolved_api_EnumFilterTransformationSeriesNode"] = None
+    _value_map: Optional["scout_compute_resolved_api_ValueMapSeriesNode"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
@@ -47280,7 +48460,8 @@ class scout_compute_resolved_api_EnumSeriesNode(ConjureUnionType):
             'time_shift': ConjureFieldDefinition('timeShift', scout_compute_resolved_api_EnumTimeShiftSeriesNode),
             'union': ConjureFieldDefinition('union', scout_compute_resolved_api_EnumUnionSeriesNode),
             'aggregate': ConjureFieldDefinition('aggregate', scout_compute_resolved_api_AggregateEnumSeriesNode),
-            'filter_transformation': ConjureFieldDefinition('filterTransformation', scout_compute_resolved_api_EnumFilterTransformationSeriesNode)
+            'filter_transformation': ConjureFieldDefinition('filterTransformation', scout_compute_resolved_api_EnumFilterTransformationSeriesNode),
+            'value_map': ConjureFieldDefinition('valueMap', scout_compute_resolved_api_ValueMapSeriesNode)
         }
 
     def __init__(
@@ -47292,10 +48473,11 @@ class scout_compute_resolved_api_EnumSeriesNode(ConjureUnionType):
             union: Optional["scout_compute_resolved_api_EnumUnionSeriesNode"] = None,
             aggregate: Optional["scout_compute_resolved_api_AggregateEnumSeriesNode"] = None,
             filter_transformation: Optional["scout_compute_resolved_api_EnumFilterTransformationSeriesNode"] = None,
+            value_map: Optional["scout_compute_resolved_api_ValueMapSeriesNode"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (raw is not None) + (resample is not None) + (time_range_filter is not None) + (time_shift is not None) + (union is not None) + (aggregate is not None) + (filter_transformation is not None) != 1:
+            if (raw is not None) + (resample is not None) + (time_range_filter is not None) + (time_shift is not None) + (union is not None) + (aggregate is not None) + (filter_transformation is not None) + (value_map is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if raw is not None:
@@ -47319,6 +48501,9 @@ class scout_compute_resolved_api_EnumSeriesNode(ConjureUnionType):
             if filter_transformation is not None:
                 self._filter_transformation = filter_transformation
                 self._type = 'filterTransformation'
+            if value_map is not None:
+                self._value_map = value_map
+                self._type = 'valueMap'
 
         elif type_of_union == 'raw':
             if raw is None:
@@ -47355,6 +48540,11 @@ class scout_compute_resolved_api_EnumSeriesNode(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._filter_transformation = filter_transformation
             self._type = 'filterTransformation'
+        elif type_of_union == 'valueMap':
+            if value_map is None:
+                raise ValueError('a union value must not be None')
+            self._value_map = value_map
+            self._type = 'valueMap'
 
     @builtins.property
     def raw(self) -> Optional["scout_compute_resolved_api_RawEnumSeriesNode"]:
@@ -47384,6 +48574,10 @@ class scout_compute_resolved_api_EnumSeriesNode(ConjureUnionType):
     def filter_transformation(self) -> Optional["scout_compute_resolved_api_EnumFilterTransformationSeriesNode"]:
         return self._filter_transformation
 
+    @builtins.property
+    def value_map(self) -> Optional["scout_compute_resolved_api_ValueMapSeriesNode"]:
+        return self._value_map
+
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, scout_compute_resolved_api_EnumSeriesNodeVisitor):
             raise ValueError('{} is not an instance of scout_compute_resolved_api_EnumSeriesNodeVisitor'.format(visitor.__class__.__name__))
@@ -47401,6 +48595,8 @@ class scout_compute_resolved_api_EnumSeriesNode(ConjureUnionType):
             return visitor._aggregate(self.aggregate)
         if self._type == 'filterTransformation' and self.filter_transformation is not None:
             return visitor._filter_transformation(self.filter_transformation)
+        if self._type == 'valueMap' and self.value_map is not None:
+            return visitor._value_map(self.value_map)
 
 
 scout_compute_resolved_api_EnumSeriesNode.__name__ = "EnumSeriesNode"
@@ -47438,6 +48634,10 @@ class scout_compute_resolved_api_EnumSeriesNodeVisitor:
     def _filter_transformation(self, filter_transformation: "scout_compute_resolved_api_EnumFilterTransformationSeriesNode") -> Any:
         pass
 
+    @abstractmethod
+    def _value_map(self, value_map: "scout_compute_resolved_api_ValueMapSeriesNode") -> Any:
+        pass
+
 
 scout_compute_resolved_api_EnumSeriesNodeVisitor.__name__ = "EnumSeriesNodeVisitor"
 scout_compute_resolved_api_EnumSeriesNodeVisitor.__qualname__ = "EnumSeriesNodeVisitor"
@@ -47537,6 +48737,29 @@ scout_compute_resolved_api_EnumUnionSeriesNode.__qualname__ = "EnumUnionSeriesNo
 scout_compute_resolved_api_EnumUnionSeriesNode.__module__ = "nominal_api.scout_compute_resolved_api"
 
 
+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
+
+    @builtins.property
+    def intercept(self) -> Optional[float]:
+        return self._intercept
+
+
+scout_compute_resolved_api_ExponentialCurve.__name__ = "ExponentialCurve"
+scout_compute_resolved_api_ExponentialCurve.__qualname__ = "ExponentialCurve"
+scout_compute_resolved_api_ExponentialCurve.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
 class scout_compute_resolved_api_ExtremaRangesNode(ConjureBeanType):
 
     @builtins.classmethod
@@ -48309,6 +49532,22 @@ scout_compute_resolved_api_LogUnionSeriesNode.__qualname__ = "LogUnionSeriesNode
 scout_compute_resolved_api_LogUnionSeriesNode.__module__ = "nominal_api.scout_compute_resolved_api"
 
 
+class scout_compute_resolved_api_LogarithmicCurve(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+        }
+
+    __slots__: List[str] = []
+
+
+
+scout_compute_resolved_api_LogarithmicCurve.__name__ = "LogarithmicCurve"
+scout_compute_resolved_api_LogarithmicCurve.__qualname__ = "LogarithmicCurve"
+scout_compute_resolved_api_LogarithmicCurve.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
 class scout_compute_resolved_api_LowPassConfiguration(ConjureBeanType):
 
     @builtins.classmethod
@@ -49531,6 +50770,51 @@ scout_compute_resolved_api_PersistenceWindowConfiguration.__qualname__ = "Persis
 scout_compute_resolved_api_PersistenceWindowConfiguration.__module__ = "nominal_api.scout_compute_resolved_api"
 
 
+class scout_compute_resolved_api_PolynomialCurve(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'degree': ConjureFieldDefinition('degree', int),
+            'intercept': ConjureFieldDefinition('intercept', OptionalTypeWrapper[float])
+        }
+
+    __slots__: List[str] = ['_degree', '_intercept']
+
+    def __init__(self, degree: int, intercept: Optional[float] = None) -> None:
+        self._degree = degree
+        self._intercept = intercept
+
+    @builtins.property
+    def degree(self) -> int:
+        return self._degree
+
+    @builtins.property
+    def intercept(self) -> Optional[float]:
+        return self._intercept
+
+
+scout_compute_resolved_api_PolynomialCurve.__name__ = "PolynomialCurve"
+scout_compute_resolved_api_PolynomialCurve.__qualname__ = "PolynomialCurve"
+scout_compute_resolved_api_PolynomialCurve.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
+class scout_compute_resolved_api_PowerCurve(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+        }
+
+    __slots__: List[str] = []
+
+
+
+scout_compute_resolved_api_PowerCurve.__name__ = "PowerCurve"
+scout_compute_resolved_api_PowerCurve.__qualname__ = "PowerCurve"
+scout_compute_resolved_api_PowerCurve.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
 class scout_compute_resolved_api_ProductSeriesNode(ConjureBeanType):
 
     @builtins.classmethod
@@ -49560,6 +50844,41 @@ scout_compute_resolved_api_ProductSeriesNode.__qualname__ = "ProductSeriesNode"
 scout_compute_resolved_api_ProductSeriesNode.__module__ = "nominal_api.scout_compute_resolved_api"
 
 
+class scout_compute_resolved_api_RangeMap(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'start': ConjureFieldDefinition('start', OptionalTypeWrapper[float]),
+            'end': ConjureFieldDefinition('end', OptionalTypeWrapper[float]),
+            'output': ConjureFieldDefinition('output', str)
+        }
+
+    __slots__: List[str] = ['_start', '_end', '_output']
+
+    def __init__(self, output: str, end: Optional[float] = None, start: Optional[float] = None) -> None:
+        self._start = start
+        self._end = end
+        self._output = output
+
+    @builtins.property
+    def start(self) -> Optional[float]:
+        return self._start
+
+    @builtins.property
+    def end(self) -> Optional[float]:
+        return self._end
+
+    @builtins.property
+    def output(self) -> str:
+        return self._output
+
+
+scout_compute_resolved_api_RangeMap.__name__ = "RangeMap"
+scout_compute_resolved_api_RangeMap.__qualname__ = "RangeMap"
+scout_compute_resolved_api_RangeMap.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
 class scout_compute_resolved_api_RangesNode(ConjureUnionType):
     _enum_equality: Optional["scout_compute_resolved_api_EnumEqualityRangesNode"] = None
     _enum_filter: Optional["scout_compute_resolved_api_EnumFilterRangesNode"] = None
@@ -50089,6 +51408,7 @@ class scout_compute_resolved_api_ResolvedNode(ConjureUnionType):
     _frequency: Optional["scout_compute_resolved_api_FrequencyDomainNode"] = None
     _histogram: Optional["scout_compute_resolved_api_HistogramNode"] = None
     _geo: Optional["scout_compute_resolved_api_SummarizeGeoNode"] = None
+    _curve: Optional["scout_compute_resolved_api_CurveFitNode"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
@@ -50100,7 +51420,8 @@ class scout_compute_resolved_api_ResolvedNode(ConjureUnionType):
             'cartesian3d': ConjureFieldDefinition('cartesian3d', scout_compute_resolved_api_SummarizeCartesian3dNode),
             'frequency': ConjureFieldDefinition('frequency', scout_compute_resolved_api_FrequencyDomainNode),
             'histogram': ConjureFieldDefinition('histogram', scout_compute_resolved_api_HistogramNode),
-            'geo': ConjureFieldDefinition('geo', scout_compute_resolved_api_SummarizeGeoNode)
+            'geo': ConjureFieldDefinition('geo', scout_compute_resolved_api_SummarizeGeoNode),
+            'curve': ConjureFieldDefinition('curve', scout_compute_resolved_api_CurveFitNode)
         }
 
     def __init__(
@@ -50113,10 +51434,11 @@ class scout_compute_resolved_api_ResolvedNode(ConjureUnionType):
             frequency: Optional["scout_compute_resolved_api_FrequencyDomainNode"] = None,
             histogram: Optional["scout_compute_resolved_api_HistogramNode"] = None,
             geo: Optional["scout_compute_resolved_api_SummarizeGeoNode"] = None,
+            curve: Optional["scout_compute_resolved_api_CurveFitNode"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (ranges is not None) + (series is not None) + (value is not None) + (cartesian is not None) + (cartesian3d is not None) + (frequency is not None) + (histogram is not None) + (geo is not None) != 1:
+            if (ranges is not None) + (series is not None) + (value is not None) + (cartesian is not None) + (cartesian3d is not None) + (frequency is not None) + (histogram is not None) + (geo is not None) + (curve is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if ranges is not None:
@@ -50143,6 +51465,9 @@ class scout_compute_resolved_api_ResolvedNode(ConjureUnionType):
             if geo is not None:
                 self._geo = geo
                 self._type = 'geo'
+            if curve is not None:
+                self._curve = curve
+                self._type = 'curve'
 
         elif type_of_union == 'ranges':
             if ranges is None:
@@ -50184,6 +51509,11 @@ class scout_compute_resolved_api_ResolvedNode(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._geo = geo
             self._type = 'geo'
+        elif type_of_union == 'curve':
+            if curve is None:
+                raise ValueError('a union value must not be None')
+            self._curve = curve
+            self._type = 'curve'
 
     @builtins.property
     def ranges(self) -> Optional["scout_compute_resolved_api_SummarizeRangesNode"]:
@@ -50217,6 +51547,10 @@ class scout_compute_resolved_api_ResolvedNode(ConjureUnionType):
     def geo(self) -> Optional["scout_compute_resolved_api_SummarizeGeoNode"]:
         return self._geo
 
+    @builtins.property
+    def curve(self) -> Optional["scout_compute_resolved_api_CurveFitNode"]:
+        return self._curve
+
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, scout_compute_resolved_api_ResolvedNodeVisitor):
             raise ValueError('{} is not an instance of scout_compute_resolved_api_ResolvedNodeVisitor'.format(visitor.__class__.__name__))
@@ -50236,6 +51570,8 @@ class scout_compute_resolved_api_ResolvedNode(ConjureUnionType):
             return visitor._histogram(self.histogram)
         if self._type == 'geo' and self.geo is not None:
             return visitor._geo(self.geo)
+        if self._type == 'curve' and self.curve is not None:
+            return visitor._curve(self.curve)
 
 
 scout_compute_resolved_api_ResolvedNode.__name__ = "ResolvedNode"
@@ -50277,6 +51613,10 @@ class scout_compute_resolved_api_ResolvedNodeVisitor:
     def _geo(self, geo: "scout_compute_resolved_api_SummarizeGeoNode") -> Any:
         pass
 
+    @abstractmethod
+    def _curve(self, curve: "scout_compute_resolved_api_CurveFitNode") -> Any:
+        pass
+
 
 scout_compute_resolved_api_ResolvedNodeVisitor.__name__ = "ResolvedNodeVisitor"
 scout_compute_resolved_api_ResolvedNodeVisitor.__qualname__ = "ResolvedNodeVisitor"
@@ -50435,6 +51775,76 @@ scout_compute_resolved_api_Scatter3dNode.__qualname__ = "Scatter3dNode"
 scout_compute_resolved_api_Scatter3dNode.__module__ = "nominal_api.scout_compute_resolved_api"
 
 
+class scout_compute_resolved_api_ScatterCurveFitNode(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'scatter': ConjureFieldDefinition('scatter', scout_compute_resolved_api_ScatterNode),
+            'options': ConjureFieldDefinition('options', scout_compute_resolved_api_ScatterFitOptions)
+        }
+
+    __slots__: List[str] = ['_scatter', '_options']
+
+    def __init__(self, options: "scout_compute_resolved_api_ScatterFitOptions", scatter: "scout_compute_resolved_api_ScatterNode") -> None:
+        self._scatter = scatter
+        self._options = options
+
+    @builtins.property
+    def scatter(self) -> "scout_compute_resolved_api_ScatterNode":
+        return self._scatter
+
+    @builtins.property
+    def options(self) -> "scout_compute_resolved_api_ScatterFitOptions":
+        return self._options
+
+
+scout_compute_resolved_api_ScatterCurveFitNode.__name__ = "ScatterCurveFitNode"
+scout_compute_resolved_api_ScatterCurveFitNode.__qualname__ = "ScatterCurveFitNode"
+scout_compute_resolved_api_ScatterCurveFitNode.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
+class scout_compute_resolved_api_ScatterFitOptions(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'min_x': ConjureFieldDefinition('minX', OptionalTypeWrapper[float]),
+            'max_x': ConjureFieldDefinition('maxX', OptionalTypeWrapper[float]),
+            'min_y': ConjureFieldDefinition('minY', OptionalTypeWrapper[float]),
+            'max_y': ConjureFieldDefinition('maxY', OptionalTypeWrapper[float])
+        }
+
+    __slots__: List[str] = ['_min_x', '_max_x', '_min_y', '_max_y']
+
+    def __init__(self, max_x: Optional[float] = None, max_y: Optional[float] = None, min_x: Optional[float] = None, min_y: Optional[float] = None) -> None:
+        self._min_x = min_x
+        self._max_x = max_x
+        self._min_y = min_y
+        self._max_y = max_y
+
+    @builtins.property
+    def min_x(self) -> Optional[float]:
+        return self._min_x
+
+    @builtins.property
+    def max_x(self) -> Optional[float]:
+        return self._max_x
+
+    @builtins.property
+    def min_y(self) -> Optional[float]:
+        return self._min_y
+
+    @builtins.property
+    def max_y(self) -> Optional[float]:
+        return self._max_y
+
+
+scout_compute_resolved_api_ScatterFitOptions.__name__ = "ScatterFitOptions"
+scout_compute_resolved_api_ScatterFitOptions.__qualname__ = "ScatterFitOptions"
+scout_compute_resolved_api_ScatterFitOptions.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
 class scout_compute_resolved_api_ScatterNode(ConjureBeanType):
 
     @builtins.classmethod
@@ -51399,6 +52809,58 @@ scout_compute_resolved_api_TimeDifferenceSeriesNode.__qualname__ = "TimeDifferen
 scout_compute_resolved_api_TimeDifferenceSeriesNode.__module__ = "nominal_api.scout_compute_resolved_api"
 
 
+class scout_compute_resolved_api_TimeSeriesCurveFitNode(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'series': ConjureFieldDefinition('series', scout_compute_resolved_api_NumericSeriesNode),
+            'options': ConjureFieldDefinition('options', scout_compute_resolved_api_TimeSeriesFitOptions)
+        }
+
+    __slots__: List[str] = ['_series', '_options']
+
+    def __init__(self, options: "scout_compute_resolved_api_TimeSeriesFitOptions", series: "scout_compute_resolved_api_NumericSeriesNode") -> None:
+        self._series = series
+        self._options = options
+
+    @builtins.property
+    def series(self) -> "scout_compute_resolved_api_NumericSeriesNode":
+        return self._series
+
+    @builtins.property
+    def options(self) -> "scout_compute_resolved_api_TimeSeriesFitOptions":
+        return self._options
+
+
+scout_compute_resolved_api_TimeSeriesCurveFitNode.__name__ = "TimeSeriesCurveFitNode"
+scout_compute_resolved_api_TimeSeriesCurveFitNode.__qualname__ = "TimeSeriesCurveFitNode"
+scout_compute_resolved_api_TimeSeriesCurveFitNode.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
+class scout_compute_resolved_api_TimeSeriesFitOptions(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'time_unit': ConjureFieldDefinition('timeUnit', OptionalTypeWrapper[api_TimeUnit])
+        }
+
+    __slots__: List[str] = ['_time_unit']
+
+    def __init__(self, time_unit: Optional["api_TimeUnit"] = None) -> None:
+        self._time_unit = time_unit
+
+    @builtins.property
+    def time_unit(self) -> Optional["api_TimeUnit"]:
+        return self._time_unit
+
+
+scout_compute_resolved_api_TimeSeriesFitOptions.__name__ = "TimeSeriesFitOptions"
+scout_compute_resolved_api_TimeSeriesFitOptions.__qualname__ = "TimeSeriesFitOptions"
+scout_compute_resolved_api_TimeSeriesFitOptions.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
 class scout_compute_resolved_api_UnaryArithmeticSeriesNode(ConjureBeanType):
 
     @builtins.classmethod
@@ -51509,6 +52971,41 @@ scout_compute_resolved_api_ValueDifferenceSeriesNode.__qualname__ = "ValueDiffer
 scout_compute_resolved_api_ValueDifferenceSeriesNode.__module__ = "nominal_api.scout_compute_resolved_api"
 
 
+class scout_compute_resolved_api_ValueMapSeriesNode(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'input': ConjureFieldDefinition('input', scout_compute_resolved_api_NumericSeriesNode),
+            'mapping': ConjureFieldDefinition('mapping', List[scout_compute_resolved_api_RangeMap]),
+            'fallback': ConjureFieldDefinition('fallback', OptionalTypeWrapper[str])
+        }
+
+    __slots__: List[str] = ['_input', '_mapping', '_fallback']
+
+    def __init__(self, input: "scout_compute_resolved_api_NumericSeriesNode", mapping: List["scout_compute_resolved_api_RangeMap"], fallback: Optional[str] = None) -> None:
+        self._input = input
+        self._mapping = mapping
+        self._fallback = fallback
+
+    @builtins.property
+    def input(self) -> "scout_compute_resolved_api_NumericSeriesNode":
+        return self._input
+
+    @builtins.property
+    def mapping(self) -> List["scout_compute_resolved_api_RangeMap"]:
+        return self._mapping
+
+    @builtins.property
+    def fallback(self) -> Optional[str]:
+        return self._fallback
+
+
+scout_compute_resolved_api_ValueMapSeriesNode.__name__ = "ValueMapSeriesNode"
+scout_compute_resolved_api_ValueMapSeriesNode.__qualname__ = "ValueMapSeriesNode"
+scout_compute_resolved_api_ValueMapSeriesNode.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
 class scout_compute_resolved_api_Window(ConjureBeanType):
 
     @builtins.classmethod