nominal-api 0.634.0__py3-none-any.whl → 0.637.0__py3-none-any.whl

nominal_api/_impl.py

@@ -11494,17 +11494,19 @@ class ingest_workflow_api_EnsureExtractorJobCreatedRequest(ConjureBeanType):
             'ingest_job_uuid': ConjureFieldDefinition('ingestJobUuid', str),
             'containerized_extractor': ConjureFieldDefinition('containerizedExtractor', ingest_api_ContainerizedExtractor),
             'source_handles': ConjureFieldDefinition('sourceHandles', Dict[str, scout_catalog_S3Handle]),
-            'multipart_upload_details': ConjureFieldDefinition('multipartUploadDetails', ingest_workflow_api_MultipartUploadDetails)
+            'multipart_upload_details': ConjureFieldDefinition('multipartUploadDetails', ingest_workflow_api_MultipartUploadDetails),
+            'image_pull_secret_name': ConjureFieldDefinition('imagePullSecretName', OptionalTypeWrapper[str])
         }
 
-    __slots__: List[str] = ['_workspace_rid', '_ingest_job_uuid', '_containerized_extractor', '_source_handles', '_multipart_upload_details']
+    __slots__: List[str] = ['_workspace_rid', '_ingest_job_uuid', '_containerized_extractor', '_source_handles', '_multipart_upload_details', '_image_pull_secret_name']
 
-    def __init__(self, containerized_extractor: "ingest_api_ContainerizedExtractor", ingest_job_uuid: str, multipart_upload_details: "ingest_workflow_api_MultipartUploadDetails", source_handles: Dict[str, "scout_catalog_S3Handle"], workspace_rid: str) -> None:
+    def __init__(self, containerized_extractor: "ingest_api_ContainerizedExtractor", ingest_job_uuid: str, multipart_upload_details: "ingest_workflow_api_MultipartUploadDetails", source_handles: Dict[str, "scout_catalog_S3Handle"], workspace_rid: str, image_pull_secret_name: Optional[str] = None) -> None:
         self._workspace_rid = workspace_rid
         self._ingest_job_uuid = ingest_job_uuid
         self._containerized_extractor = containerized_extractor
         self._source_handles = source_handles
         self._multipart_upload_details = multipart_upload_details
+        self._image_pull_secret_name = image_pull_secret_name
 
     @builtins.property
     def workspace_rid(self) -> str:
@@ -11526,6 +11528,13 @@ class ingest_workflow_api_EnsureExtractorJobCreatedRequest(ConjureBeanType):
     def multipart_upload_details(self) -> "ingest_workflow_api_MultipartUploadDetails":
         return self._multipart_upload_details
 
+    @builtins.property
+    def image_pull_secret_name(self) -> Optional[str]:
+        """
+        Name of the Kubernetes secret to use for pulling the image, if authentication is required.
+        """
+        return self._image_pull_secret_name
+
 
 ingest_workflow_api_EnsureExtractorJobCreatedRequest.__name__ = "EnsureExtractorJobCreatedRequest"
 ingest_workflow_api_EnsureExtractorJobCreatedRequest.__qualname__ = "EnsureExtractorJobCreatedRequest"
@@ -11548,6 +11557,80 @@ ingest_workflow_api_EnsureExtractorJobCreatedResponse.__qualname__ = "EnsureExtr
 ingest_workflow_api_EnsureExtractorJobCreatedResponse.__module__ = "nominal_api.ingest_workflow_api"
 
 
+class ingest_workflow_api_EnsureImagePullSecretCreatedRequest(ConjureBeanType):
+    """
+    Ensures a Kubernetes secret of type kubernetes.io/dockerconfigjson exists
+for the given registry credentials.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'workspace_rid': ConjureFieldDefinition('workspaceRid', api_rids_WorkspaceRid),
+            'image_source': ConjureFieldDefinition('imageSource', ingest_api_DockerImageSource),
+            'authentication': ConjureFieldDefinition('authentication', ingest_api_UserAndPasswordAuthentication),
+            'ingest_job_uuid': ConjureFieldDefinition('ingestJobUuid', str),
+            'bearer_token': ConjureFieldDefinition('bearerToken', str)
+        }
+
+    __slots__: List[str] = ['_workspace_rid', '_image_source', '_authentication', '_ingest_job_uuid', '_bearer_token']
+
+    def __init__(self, authentication: "ingest_api_UserAndPasswordAuthentication", bearer_token: str, image_source: "ingest_api_DockerImageSource", ingest_job_uuid: str, workspace_rid: str) -> None:
+        self._workspace_rid = workspace_rid
+        self._image_source = image_source
+        self._authentication = authentication
+        self._ingest_job_uuid = ingest_job_uuid
+        self._bearer_token = bearer_token
+
+    @builtins.property
+    def workspace_rid(self) -> str:
+        return self._workspace_rid
+
+    @builtins.property
+    def image_source(self) -> "ingest_api_DockerImageSource":
+        return self._image_source
+
+    @builtins.property
+    def authentication(self) -> "ingest_api_UserAndPasswordAuthentication":
+        return self._authentication
+
+    @builtins.property
+    def ingest_job_uuid(self) -> str:
+        return self._ingest_job_uuid
+
+    @builtins.property
+    def bearer_token(self) -> str:
+        return self._bearer_token
+
+
+ingest_workflow_api_EnsureImagePullSecretCreatedRequest.__name__ = "EnsureImagePullSecretCreatedRequest"
+ingest_workflow_api_EnsureImagePullSecretCreatedRequest.__qualname__ = "EnsureImagePullSecretCreatedRequest"
+ingest_workflow_api_EnsureImagePullSecretCreatedRequest.__module__ = "nominal_api.ingest_workflow_api"
+
+
+class ingest_workflow_api_EnsureImagePullSecretCreatedResponse(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'secret_name': ConjureFieldDefinition('secretName', str)
+        }
+
+    __slots__: List[str] = ['_secret_name']
+
+    def __init__(self, secret_name: str) -> None:
+        self._secret_name = secret_name
+
+    @builtins.property
+    def secret_name(self) -> str:
+        return self._secret_name
+
+
+ingest_workflow_api_EnsureImagePullSecretCreatedResponse.__name__ = "EnsureImagePullSecretCreatedResponse"
+ingest_workflow_api_EnsureImagePullSecretCreatedResponse.__qualname__ = "EnsureImagePullSecretCreatedResponse"
+ingest_workflow_api_EnsureImagePullSecretCreatedResponse.__module__ = "nominal_api.ingest_workflow_api"
+
+
 class ingest_workflow_api_EnsureWorkspaceNamespaceCreatedRequest(ConjureBeanType):
     """
     For a given workspace rid, ensures that there is a corresponding K8s namespace created.
@@ -12655,7 +12738,9 @@ class persistent_compute_api_ShutdownNotice(ConjureBeanType):
     Indicates that the websocket will shut down in the near future. Until it is, SubscriptionUpdates will 
 still be sent to the client. Clients that want to avoid downtime or latency spikes should initiate a new 
 websocket and recreate all their subscriptions there but still keep this websocket open until the new 
-websockets starts sending SubscriptionUpdates.
+websockets starts sending SubscriptionUpdates. Clients should also specify 
+`SubscriptionOptions::allowGracefulWarmUp` when creating the new subscriptions, which allows the new websocket
+to warm up before sending subscription updates, guaranteeing better performance.
     """
 
     @builtins.classmethod
@@ -12908,14 +12993,16 @@ class persistent_compute_api_SubscriptionOptions(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'min_delay': ConjureFieldDefinition('minDelay', persistent_compute_api_Milliseconds),
-            'allow_appends': ConjureFieldDefinition('allowAppends', OptionalTypeWrapper[bool])
+            'allow_appends': ConjureFieldDefinition('allowAppends', OptionalTypeWrapper[bool]),
+            'allow_graceful_warm_up': ConjureFieldDefinition('allowGracefulWarmUp', OptionalTypeWrapper[bool])
         }
 
-    __slots__: List[str] = ['_min_delay', '_allow_appends']
+    __slots__: List[str] = ['_min_delay', '_allow_appends', '_allow_graceful_warm_up']
 
-    def __init__(self, min_delay: int, allow_appends: Optional[bool] = None) -> None:
+    def __init__(self, min_delay: int, allow_appends: Optional[bool] = None, allow_graceful_warm_up: Optional[bool] = None) -> None:
         self._min_delay = min_delay
         self._allow_appends = allow_appends
+        self._allow_graceful_warm_up = allow_graceful_warm_up
 
     @builtins.property
     def min_delay(self) -> int:
@@ -12937,6 +13024,15 @@ implement support.
         """
         return self._allow_appends
 
+    @builtins.property
+    def allow_graceful_warm_up(self) -> Optional[bool]:
+        """
+        If true, the subscriptions will be allowed to warm up before sending results, in order to guarantee low
+latency. This should be set when doing a graceful switch based on a 
+`ServerMessage::HealthMessage::ShutdownNotice`. Defaults to `false`.
+        """
+        return self._allow_graceful_warm_up
+
 
 persistent_compute_api_SubscriptionOptions.__name__ = "SubscriptionOptions"
 persistent_compute_api_SubscriptionOptions.__qualname__ = "SubscriptionOptions"
@@ -33429,6 +33525,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]:
@@ -33440,7 +33537,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__(
@@ -33453,10 +33551,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:
@@ -33483,6 +33582,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:
@@ -33524,6 +33626,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"]:
@@ -33557,6 +33664,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__))
@@ -33576,6 +33687,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"
@@ -33617,6 +33730,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"
@@ -33864,6 +33981,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]:
@@ -33885,7 +34003,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__(
@@ -33908,10 +34027,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:
@@ -33968,6 +34088,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:
@@ -34059,6 +34182,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"]:
@@ -34132,6 +34260,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__))
@@ -34171,6 +34303,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"
@@ -34252,6 +34386,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"
@@ -34850,6 +34988,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
@@ -35609,6 +36149,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]:
@@ -35621,7 +36162,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__(
@@ -35635,10 +36177,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:
@@ -35668,6 +36211,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:
@@ -35714,6 +36260,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"]:
@@ -35751,6 +36302,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__))
@@ -35772,6 +36327,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"
@@ -35817,6 +36374,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"
@@ -36100,6 +36661,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.
@@ -37545,6 +38164,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
@@ -39973,6 +40640,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
@@ -40231,6 +41007,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
@@ -41272,6 +42092,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]:
@@ -41341,6 +42165,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
 
@@ -42810,6 +43726,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
@@ -43313,6 +44291,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
@@ -47039,6 +48066,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
@@ -47271,6 +48545,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]:
@@ -47281,7 +48556,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__(
@@ -47293,10 +48569,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:
@@ -47320,6 +48597,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:
@@ -47356,6 +48636,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"]:
@@ -47385,6 +48670,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__))
@@ -47402,6 +48691,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"
@@ -47439,6 +48730,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"
@@ -47538,6 +48833,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
@@ -48310,6 +49628,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
@@ -49532,6 +50866,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
@@ -49561,6 +50940,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
@@ -50090,6 +51504,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]:
@@ -50101,7 +51516,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__(
@@ -50114,10 +51530,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:
@@ -50144,6 +51561,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:
@@ -50185,6 +51605,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"]:
@@ -50218,6 +51643,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__))
@@ -50237,6 +51666,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"
@@ -50278,6 +51709,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"
@@ -50436,6 +51871,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
@@ -51400,6 +52905,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
@@ -51510,6 +53067,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