nominal-api 0.569.1__py3-none-any.whl → 0.571.0__py3-none-any.whl

nominal_api/__init__.py

@@ -70,5 +70,5 @@ __all__ = [
 
 __conjure_generator_version__ = "4.9.0"
 
-__version__ = "0.569.1"
+__version__ = "0.571.0"
 

nominal_api/_impl.py

@@ -28503,6 +28503,29 @@ scout_compute_api_BitXorFunction.__qualname__ = "BitXorFunction"
 scout_compute_api_BitXorFunction.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_BucketedCartesian3dPlot(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'buckets': ConjureFieldDefinition('buckets', List[scout_compute_api_Cartesian3dBucket])
+        }
+
+    __slots__: List[str] = ['_buckets']
+
+    def __init__(self, buckets: List["scout_compute_api_Cartesian3dBucket"]) -> None:
+        self._buckets = buckets
+
+    @builtins.property
+    def buckets(self) -> List["scout_compute_api_Cartesian3dBucket"]:
+        return self._buckets
+
+
+scout_compute_api_BucketedCartesian3dPlot.__name__ = "BucketedCartesian3dPlot"
+scout_compute_api_BucketedCartesian3dPlot.__qualname__ = "BucketedCartesian3dPlot"
+scout_compute_api_BucketedCartesian3dPlot.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_BucketedCartesianPlot(ConjureBeanType):
 
     @builtins.classmethod
@@ -28708,6 +28731,224 @@ scout_compute_api_CartesianVisitor.__qualname__ = "CartesianVisitor"
 scout_compute_api_CartesianVisitor.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_Cartesian3d(ConjureUnionType):
+    _scatter3d: Optional["scout_compute_api_Scatter3d"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'scatter3d': ConjureFieldDefinition('scatter3d', scout_compute_api_Scatter3d)
+        }
+
+    def __init__(
+            self,
+            scatter3d: Optional["scout_compute_api_Scatter3d"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (scatter3d is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if scatter3d is not None:
+                self._scatter3d = scatter3d
+                self._type = 'scatter3d'
+
+        elif type_of_union == 'scatter3d':
+            if scatter3d is None:
+                raise ValueError('a union value must not be None')
+            self._scatter3d = scatter3d
+            self._type = 'scatter3d'
+
+    @builtins.property
+    def scatter3d(self) -> Optional["scout_compute_api_Scatter3d"]:
+        return self._scatter3d
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_compute_api_Cartesian3dVisitor):
+            raise ValueError('{} is not an instance of scout_compute_api_Cartesian3dVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'scatter3d' and self.scatter3d is not None:
+            return visitor._scatter3d(self.scatter3d)
+
+
+scout_compute_api_Cartesian3d.__name__ = "Cartesian3d"
+scout_compute_api_Cartesian3d.__qualname__ = "Cartesian3d"
+scout_compute_api_Cartesian3d.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_Cartesian3dVisitor:
+
+    @abstractmethod
+    def _scatter3d(self, scatter3d: "scout_compute_api_Scatter3d") -> Any:
+        pass
+
+
+scout_compute_api_Cartesian3dVisitor.__name__ = "Cartesian3dVisitor"
+scout_compute_api_Cartesian3dVisitor.__qualname__ = "Cartesian3dVisitor"
+scout_compute_api_Cartesian3dVisitor.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_Cartesian3dBounds(ConjureBeanType):
+    """
+    Min/max bounds of an XYZ Cartesian plot, inclusive.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'min_x': ConjureFieldDefinition('minX', scout_compute_api_DoubleConstant),
+            'max_x': ConjureFieldDefinition('maxX', scout_compute_api_DoubleConstant),
+            'min_y': ConjureFieldDefinition('minY', scout_compute_api_DoubleConstant),
+            'max_y': ConjureFieldDefinition('maxY', scout_compute_api_DoubleConstant),
+            'min_z': ConjureFieldDefinition('minZ', scout_compute_api_DoubleConstant),
+            'max_z': ConjureFieldDefinition('maxZ', scout_compute_api_DoubleConstant)
+        }
+
+    __slots__: List[str] = ['_min_x', '_max_x', '_min_y', '_max_y', '_min_z', '_max_z']
+
+    def __init__(self, max_x: "scout_compute_api_DoubleConstant", max_y: "scout_compute_api_DoubleConstant", max_z: "scout_compute_api_DoubleConstant", min_x: "scout_compute_api_DoubleConstant", min_y: "scout_compute_api_DoubleConstant", min_z: "scout_compute_api_DoubleConstant") -> None:
+        self._min_x = min_x
+        self._max_x = max_x
+        self._min_y = min_y
+        self._max_y = max_y
+        self._min_z = min_z
+        self._max_z = max_z
+
+    @builtins.property
+    def min_x(self) -> "scout_compute_api_DoubleConstant":
+        return self._min_x
+
+    @builtins.property
+    def max_x(self) -> "scout_compute_api_DoubleConstant":
+        return self._max_x
+
+    @builtins.property
+    def min_y(self) -> "scout_compute_api_DoubleConstant":
+        return self._min_y
+
+    @builtins.property
+    def max_y(self) -> "scout_compute_api_DoubleConstant":
+        return self._max_y
+
+    @builtins.property
+    def min_z(self) -> "scout_compute_api_DoubleConstant":
+        return self._min_z
+
+    @builtins.property
+    def max_z(self) -> "scout_compute_api_DoubleConstant":
+        return self._max_z
+
+
+scout_compute_api_Cartesian3dBounds.__name__ = "Cartesian3dBounds"
+scout_compute_api_Cartesian3dBounds.__qualname__ = "Cartesian3dBounds"
+scout_compute_api_Cartesian3dBounds.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_Cartesian3dBucket(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'min_x': ConjureFieldDefinition('minX', float),
+            'max_x': ConjureFieldDefinition('maxX', float),
+            'min_y': ConjureFieldDefinition('minY', float),
+            'max_y': ConjureFieldDefinition('maxY', float),
+            'min_z': ConjureFieldDefinition('minZ', float),
+            'max_z': ConjureFieldDefinition('maxZ', float),
+            'min_timestamp': ConjureFieldDefinition('minTimestamp', api_Timestamp),
+            'max_timestamp': ConjureFieldDefinition('maxTimestamp', api_Timestamp),
+            'count': ConjureFieldDefinition('count', int)
+        }
+
+    __slots__: List[str] = ['_min_x', '_max_x', '_min_y', '_max_y', '_min_z', '_max_z', '_min_timestamp', '_max_timestamp', '_count']
+
+    def __init__(self, count: int, max_timestamp: "api_Timestamp", max_x: float, max_y: float, max_z: float, min_timestamp: "api_Timestamp", min_x: float, min_y: float, min_z: float) -> None:
+        self._min_x = min_x
+        self._max_x = max_x
+        self._min_y = min_y
+        self._max_y = max_y
+        self._min_z = min_z
+        self._max_z = max_z
+        self._min_timestamp = min_timestamp
+        self._max_timestamp = max_timestamp
+        self._count = count
+
+    @builtins.property
+    def min_x(self) -> float:
+        return self._min_x
+
+    @builtins.property
+    def max_x(self) -> float:
+        return self._max_x
+
+    @builtins.property
+    def min_y(self) -> float:
+        return self._min_y
+
+    @builtins.property
+    def max_y(self) -> float:
+        return self._max_y
+
+    @builtins.property
+    def min_z(self) -> float:
+        return self._min_z
+
+    @builtins.property
+    def max_z(self) -> float:
+        return self._max_z
+
+    @builtins.property
+    def min_timestamp(self) -> "api_Timestamp":
+        return self._min_timestamp
+
+    @builtins.property
+    def max_timestamp(self) -> "api_Timestamp":
+        return self._max_timestamp
+
+    @builtins.property
+    def count(self) -> int:
+        return self._count
+
+
+scout_compute_api_Cartesian3dBucket.__name__ = "Cartesian3dBucket"
+scout_compute_api_Cartesian3dBucket.__qualname__ = "Cartesian3dBucket"
+scout_compute_api_Cartesian3dBucket.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_Cartesian3dUnitResult(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'x': ConjureFieldDefinition('x', scout_compute_api_UnitResult),
+            'y': ConjureFieldDefinition('y', scout_compute_api_UnitResult),
+            'z': ConjureFieldDefinition('z', scout_compute_api_UnitResult)
+        }
+
+    __slots__: List[str] = ['_x', '_y', '_z']
+
+    def __init__(self, x: "scout_compute_api_UnitResult", y: "scout_compute_api_UnitResult", z: "scout_compute_api_UnitResult") -> None:
+        self._x = x
+        self._y = y
+        self._z = z
+
+    @builtins.property
+    def x(self) -> "scout_compute_api_UnitResult":
+        return self._x
+
+    @builtins.property
+    def y(self) -> "scout_compute_api_UnitResult":
+        return self._y
+
+    @builtins.property
+    def z(self) -> "scout_compute_api_UnitResult":
+        return self._z
+
+
+scout_compute_api_Cartesian3dUnitResult.__name__ = "Cartesian3dUnitResult"
+scout_compute_api_Cartesian3dUnitResult.__qualname__ = "Cartesian3dUnitResult"
+scout_compute_api_Cartesian3dUnitResult.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_CartesianBounds(ConjureBeanType):
     """
     Min/max bounds of an XY Cartesian plot, inclusive.
@@ -29007,6 +29248,7 @@ class scout_compute_api_ComputableNode(ConjureUnionType):
     _series: Optional["scout_compute_api_SummarizeSeries"] = None
     _value: Optional["scout_compute_api_SelectValue"] = None
     _cartesian: Optional["scout_compute_api_SummarizeCartesian"] = None
+    _cartesian3d: Optional["scout_compute_api_SummarizeCartesian3d"] = None
     _frequency: Optional["scout_compute_api_FrequencyDomain"] = None
     _histogram: Optional["scout_compute_api_Histogram"] = None
     _geo: Optional["scout_compute_api_SummarizeGeo"] = None
@@ -29018,6 +29260,7 @@ class scout_compute_api_ComputableNode(ConjureUnionType):
             'series': ConjureFieldDefinition('series', scout_compute_api_SummarizeSeries),
             'value': ConjureFieldDefinition('value', scout_compute_api_SelectValue),
             'cartesian': ConjureFieldDefinition('cartesian', scout_compute_api_SummarizeCartesian),
+            '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)
@@ -29029,13 +29272,14 @@ class scout_compute_api_ComputableNode(ConjureUnionType):
             series: Optional["scout_compute_api_SummarizeSeries"] = None,
             value: Optional["scout_compute_api_SelectValue"] = None,
             cartesian: Optional["scout_compute_api_SummarizeCartesian"] = None,
+            cartesian3d: Optional["scout_compute_api_SummarizeCartesian3d"] = None,
             frequency: Optional["scout_compute_api_FrequencyDomain"] = None,
             histogram: Optional["scout_compute_api_Histogram"] = None,
             geo: Optional["scout_compute_api_SummarizeGeo"] = 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) + (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) != 1:
                 raise ValueError('a union must contain a single member')
 
             if ranges is not None:
@@ -29050,6 +29294,9 @@ class scout_compute_api_ComputableNode(ConjureUnionType):
             if cartesian is not None:
                 self._cartesian = cartesian
                 self._type = 'cartesian'
+            if cartesian3d is not None:
+                self._cartesian3d = cartesian3d
+                self._type = 'cartesian3d'
             if frequency is not None:
                 self._frequency = frequency
                 self._type = 'frequency'
@@ -29080,6 +29327,11 @@ class scout_compute_api_ComputableNode(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._cartesian = cartesian
             self._type = 'cartesian'
+        elif type_of_union == 'cartesian3d':
+            if cartesian3d is None:
+                raise ValueError('a union value must not be None')
+            self._cartesian3d = cartesian3d
+            self._type = 'cartesian3d'
         elif type_of_union == 'frequency':
             if frequency is None:
                 raise ValueError('a union value must not be None')
@@ -29112,6 +29364,10 @@ class scout_compute_api_ComputableNode(ConjureUnionType):
     def cartesian(self) -> Optional["scout_compute_api_SummarizeCartesian"]:
         return self._cartesian
 
+    @builtins.property
+    def cartesian3d(self) -> Optional["scout_compute_api_SummarizeCartesian3d"]:
+        return self._cartesian3d
+
     @builtins.property
     def frequency(self) -> Optional["scout_compute_api_FrequencyDomain"]:
         return self._frequency
@@ -29135,6 +29391,8 @@ class scout_compute_api_ComputableNode(ConjureUnionType):
             return visitor._value(self.value)
         if self._type == 'cartesian' and self.cartesian is not None:
             return visitor._cartesian(self.cartesian)
+        if self._type == 'cartesian3d' and self.cartesian3d is not None:
+            return visitor._cartesian3d(self.cartesian3d)
         if self._type == 'frequency' and self.frequency is not None:
             return visitor._frequency(self.frequency)
         if self._type == 'histogram' and self.histogram is not None:
@@ -29166,6 +29424,10 @@ class scout_compute_api_ComputableNodeVisitor:
     def _cartesian(self, cartesian: "scout_compute_api_SummarizeCartesian") -> Any:
         pass
 
+    @abstractmethod
+    def _cartesian3d(self, cartesian3d: "scout_compute_api_SummarizeCartesian3d") -> Any:
+        pass
+
     @abstractmethod
     def _frequency(self, frequency: "scout_compute_api_FrequencyDomain") -> Any:
         pass
@@ -29416,6 +29678,7 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
     _bucketed_enum: Optional["scout_compute_api_BucketedEnumPlot"] = None
     _cartesian: Optional["scout_compute_api_CartesianPlot"] = None
     _bucketed_cartesian: Optional["scout_compute_api_BucketedCartesianPlot"] = None
+    _bucketed_cartesian3d: Optional["scout_compute_api_BucketedCartesian3dPlot"] = None
     _bucketed_geo: Optional["scout_compute_api_BucketedGeoPlot"] = None
     _enum_point: Optional[Optional["scout_compute_api_EnumPoint"]] = None
     _numeric_point: Optional[Optional["scout_compute_api_NumericPoint"]] = None
@@ -29437,6 +29700,7 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
             'bucketed_enum': ConjureFieldDefinition('bucketedEnum', scout_compute_api_BucketedEnumPlot),
             'cartesian': ConjureFieldDefinition('cartesian', scout_compute_api_CartesianPlot),
             'bucketed_cartesian': ConjureFieldDefinition('bucketedCartesian', scout_compute_api_BucketedCartesianPlot),
+            'bucketed_cartesian3d': ConjureFieldDefinition('bucketedCartesian3d', scout_compute_api_BucketedCartesian3dPlot),
             'bucketed_geo': ConjureFieldDefinition('bucketedGeo', scout_compute_api_BucketedGeoPlot),
             'enum_point': ConjureFieldDefinition('enumPoint', OptionalTypeWrapper[scout_compute_api_EnumPoint]),
             'numeric_point': ConjureFieldDefinition('numericPoint', OptionalTypeWrapper[scout_compute_api_NumericPoint]),
@@ -29458,6 +29722,7 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
             bucketed_enum: Optional["scout_compute_api_BucketedEnumPlot"] = None,
             cartesian: Optional["scout_compute_api_CartesianPlot"] = None,
             bucketed_cartesian: Optional["scout_compute_api_BucketedCartesianPlot"] = None,
+            bucketed_cartesian3d: Optional["scout_compute_api_BucketedCartesian3dPlot"] = None,
             bucketed_geo: Optional["scout_compute_api_BucketedGeoPlot"] = None,
             enum_point: Optional[Optional["scout_compute_api_EnumPoint"]] = None,
             numeric_point: Optional[Optional["scout_compute_api_NumericPoint"]] = None,
@@ -29469,7 +29734,7 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (numeric is not None) + (bucketed_numeric is not None) + (range is not None) + (ranges_summary is not None) + (enum is not None) + (paged_log is not None) + (bucketed_enum is not None) + (cartesian is not None) + (bucketed_cartesian is not None) + (bucketed_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) != 1:
                 raise ValueError('a union must contain a single member')
 
             if numeric is not None:
@@ -29499,6 +29764,9 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
             if bucketed_cartesian is not None:
                 self._bucketed_cartesian = bucketed_cartesian
                 self._type = 'bucketedCartesian'
+            if bucketed_cartesian3d is not None:
+                self._bucketed_cartesian3d = bucketed_cartesian3d
+                self._type = 'bucketedCartesian3d'
             if bucketed_geo is not None:
                 self._bucketed_geo = bucketed_geo
                 self._type = 'bucketedGeo'
@@ -29569,6 +29837,11 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._bucketed_cartesian = bucketed_cartesian
             self._type = 'bucketedCartesian'
+        elif type_of_union == 'bucketedCartesian3d':
+            if bucketed_cartesian3d is None:
+                raise ValueError('a union value must not be None')
+            self._bucketed_cartesian3d = bucketed_cartesian3d
+            self._type = 'bucketedCartesian3d'
         elif type_of_union == 'bucketedGeo':
             if bucketed_geo is None:
                 raise ValueError('a union value must not be None')
@@ -29646,6 +29919,10 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
     def bucketed_cartesian(self) -> Optional["scout_compute_api_BucketedCartesianPlot"]:
         return self._bucketed_cartesian
 
+    @builtins.property
+    def bucketed_cartesian3d(self) -> Optional["scout_compute_api_BucketedCartesian3dPlot"]:
+        return self._bucketed_cartesian3d
+
     @builtins.property
     def bucketed_geo(self) -> Optional["scout_compute_api_BucketedGeoPlot"]:
         return self._bucketed_geo
@@ -29699,6 +29976,8 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
             return visitor._cartesian(self.cartesian)
         if self._type == 'bucketedCartesian' and self.bucketed_cartesian is not None:
             return visitor._bucketed_cartesian(self.bucketed_cartesian)
+        if self._type == 'bucketedCartesian3d' and self.bucketed_cartesian3d is not None:
+            return visitor._bucketed_cartesian3d(self.bucketed_cartesian3d)
         if self._type == 'bucketedGeo' and self.bucketed_geo is not None:
             return visitor._bucketed_geo(self.bucketed_geo)
         if self._type == 'enumPoint' and self.enum_point is not None:
@@ -29760,6 +30039,10 @@ class scout_compute_api_ComputeNodeResponseVisitor:
     def _bucketed_cartesian(self, bucketed_cartesian: "scout_compute_api_BucketedCartesianPlot") -> Any:
         pass
 
+    @abstractmethod
+    def _bucketed_cartesian3d(self, bucketed_cartesian3d: "scout_compute_api_BucketedCartesian3dPlot") -> Any:
+        pass
+
     @abstractmethod
     def _bucketed_geo(self, bucketed_geo: "scout_compute_api_BucketedGeoPlot") -> Any:
         pass
@@ -30123,22 +30406,25 @@ scout_compute_api_ComputeService.__module__ = "nominal_api.scout_compute_api"
 class scout_compute_api_ComputeUnitResult(ConjureUnionType):
     _single: Optional["scout_compute_api_UnitResult"] = None
     _cartesian: Optional["scout_compute_api_CartesianUnitResult"] = None
+    _cartesian3d: Optional["scout_compute_api_Cartesian3dUnitResult"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'single': ConjureFieldDefinition('single', scout_compute_api_UnitResult),
-            'cartesian': ConjureFieldDefinition('cartesian', scout_compute_api_CartesianUnitResult)
+            'cartesian': ConjureFieldDefinition('cartesian', scout_compute_api_CartesianUnitResult),
+            'cartesian3d': ConjureFieldDefinition('cartesian3d', scout_compute_api_Cartesian3dUnitResult)
         }
 
     def __init__(
             self,
             single: Optional["scout_compute_api_UnitResult"] = None,
             cartesian: Optional["scout_compute_api_CartesianUnitResult"] = None,
+            cartesian3d: Optional["scout_compute_api_Cartesian3dUnitResult"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (single is not None) + (cartesian is not None) != 1:
+            if (single is not None) + (cartesian is not None) + (cartesian3d is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if single is not None:
@@ -30147,6 +30433,9 @@ class scout_compute_api_ComputeUnitResult(ConjureUnionType):
             if cartesian is not None:
                 self._cartesian = cartesian
                 self._type = 'cartesian'
+            if cartesian3d is not None:
+                self._cartesian3d = cartesian3d
+                self._type = 'cartesian3d'
 
         elif type_of_union == 'single':
             if single is None:
@@ -30158,6 +30447,11 @@ class scout_compute_api_ComputeUnitResult(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._cartesian = cartesian
             self._type = 'cartesian'
+        elif type_of_union == 'cartesian3d':
+            if cartesian3d is None:
+                raise ValueError('a union value must not be None')
+            self._cartesian3d = cartesian3d
+            self._type = 'cartesian3d'
 
     @builtins.property
     def single(self) -> Optional["scout_compute_api_UnitResult"]:
@@ -30167,6 +30461,10 @@ class scout_compute_api_ComputeUnitResult(ConjureUnionType):
     def cartesian(self) -> Optional["scout_compute_api_CartesianUnitResult"]:
         return self._cartesian
 
+    @builtins.property
+    def cartesian3d(self) -> Optional["scout_compute_api_Cartesian3dUnitResult"]:
+        return self._cartesian3d
+
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, scout_compute_api_ComputeUnitResultVisitor):
             raise ValueError('{} is not an instance of scout_compute_api_ComputeUnitResultVisitor'.format(visitor.__class__.__name__))
@@ -30174,6 +30472,8 @@ class scout_compute_api_ComputeUnitResult(ConjureUnionType):
             return visitor._single(self.single)
         if self._type == 'cartesian' and self.cartesian is not None:
             return visitor._cartesian(self.cartesian)
+        if self._type == 'cartesian3d' and self.cartesian3d is not None:
+            return visitor._cartesian3d(self.cartesian3d)
 
 
 scout_compute_api_ComputeUnitResult.__name__ = "ComputeUnitResult"
@@ -30191,6 +30491,10 @@ class scout_compute_api_ComputeUnitResultVisitor:
     def _cartesian(self, cartesian: "scout_compute_api_CartesianUnitResult") -> Any:
         pass
 
+    @abstractmethod
+    def _cartesian3d(self, cartesian3d: "scout_compute_api_Cartesian3dUnitResult") -> Any:
+        pass
+
 
 scout_compute_api_ComputeUnitResultVisitor.__name__ = "ComputeUnitResultVisitor"
 scout_compute_api_ComputeUnitResultVisitor.__qualname__ = "ComputeUnitResultVisitor"
@@ -30659,6 +30963,26 @@ scout_compute_api_DoubleConstantVisitor.__qualname__ = "DoubleConstantVisitor"
 scout_compute_api_DoubleConstantVisitor.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_DriverSeries3d(ConjureEnumType):
+
+    X = 'X'
+    '''X'''
+    Y = 'Y'
+    '''Y'''
+    Z = 'Z'
+    '''Z'''
+    UNKNOWN = 'UNKNOWN'
+    '''UNKNOWN'''
+
+    def __reduce_ex__(self, proto):
+        return self.__class__, (self.name,)
+
+
+scout_compute_api_DriverSeries3d.__name__ = "DriverSeries3d"
+scout_compute_api_DriverSeries3d.__qualname__ = "DriverSeries3d"
+scout_compute_api_DriverSeries3d.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_DurationConstant(ConjureUnionType):
     _literal: Optional["scout_run_api_Duration"] = None
     _variable: Optional[str] = None
@@ -36758,6 +37082,103 @@ scout_compute_api_Scatter.__qualname__ = "Scatter"
 scout_compute_api_Scatter.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_Scatter3d(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'x': ConjureFieldDefinition('x', scout_compute_api_NumericSeries),
+            'y': ConjureFieldDefinition('y', scout_compute_api_NumericSeries),
+            'z': ConjureFieldDefinition('z', scout_compute_api_NumericSeries),
+            'driver_series': ConjureFieldDefinition('driverSeries', OptionalTypeWrapper[scout_compute_api_DriverSeries3d])
+        }
+
+    __slots__: List[str] = ['_x', '_y', '_z', '_driver_series']
+
+    def __init__(self, x: "scout_compute_api_NumericSeries", y: "scout_compute_api_NumericSeries", z: "scout_compute_api_NumericSeries", driver_series: Optional["scout_compute_api_DriverSeries3d"] = None) -> None:
+        self._x = x
+        self._y = y
+        self._z = z
+        self._driver_series = driver_series
+
+    @builtins.property
+    def x(self) -> "scout_compute_api_NumericSeries":
+        return self._x
+
+    @builtins.property
+    def y(self) -> "scout_compute_api_NumericSeries":
+        return self._y
+
+    @builtins.property
+    def z(self) -> "scout_compute_api_NumericSeries":
+        return self._z
+
+    @builtins.property
+    def driver_series(self) -> Optional["scout_compute_api_DriverSeries3d"]:
+        return self._driver_series
+
+
+scout_compute_api_Scatter3d.__name__ = "Scatter3d"
+scout_compute_api_Scatter3d.__qualname__ = "Scatter3d"
+scout_compute_api_Scatter3d.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_ScatterSummarizationStrategy(ConjureUnionType):
+    _spatial: Optional["scout_compute_api_SpatialDecimateStrategy"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'spatial': ConjureFieldDefinition('spatial', scout_compute_api_SpatialDecimateStrategy)
+        }
+
+    def __init__(
+            self,
+            spatial: Optional["scout_compute_api_SpatialDecimateStrategy"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (spatial is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if spatial is not None:
+                self._spatial = spatial
+                self._type = 'spatial'
+
+        elif type_of_union == 'spatial':
+            if spatial is None:
+                raise ValueError('a union value must not be None')
+            self._spatial = spatial
+            self._type = 'spatial'
+
+    @builtins.property
+    def spatial(self) -> Optional["scout_compute_api_SpatialDecimateStrategy"]:
+        return self._spatial
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_compute_api_ScatterSummarizationStrategyVisitor):
+            raise ValueError('{} is not an instance of scout_compute_api_ScatterSummarizationStrategyVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'spatial' and self.spatial is not None:
+            return visitor._spatial(self.spatial)
+
+
+scout_compute_api_ScatterSummarizationStrategy.__name__ = "ScatterSummarizationStrategy"
+scout_compute_api_ScatterSummarizationStrategy.__qualname__ = "ScatterSummarizationStrategy"
+scout_compute_api_ScatterSummarizationStrategy.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_ScatterSummarizationStrategyVisitor:
+
+    @abstractmethod
+    def _spatial(self, spatial: "scout_compute_api_SpatialDecimateStrategy") -> Any:
+        pass
+
+
+scout_compute_api_ScatterSummarizationStrategyVisitor.__name__ = "ScatterSummarizationStrategyVisitor"
+scout_compute_api_ScatterSummarizationStrategyVisitor.__qualname__ = "ScatterSummarizationStrategyVisitor"
+scout_compute_api_ScatterSummarizationStrategyVisitor.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_SelectValue(ConjureUnionType):
     _first_point: Optional["scout_compute_api_Series"] = None
     _first_range: Optional["scout_compute_api_RangeSeries"] = None
@@ -37282,6 +37703,27 @@ scout_compute_api_SignalFilterSeries.__qualname__ = "SignalFilterSeries"
 scout_compute_api_SignalFilterSeries.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_SpatialDecimateStrategy(ConjureBeanType):
+    """
+    Decimate by spatial trees.
+Creates buckets by bisecting on each dimension, creating quadrants for 2d scatter and octants for 3d scatter.
+Continues subdividing by prioritizing larger undivided buckets until reaching the max amount of buckets.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+        }
+
+    __slots__: List[str] = []
+
+
+
+scout_compute_api_SpatialDecimateStrategy.__name__ = "SpatialDecimateStrategy"
+scout_compute_api_SpatialDecimateStrategy.__qualname__ = "SpatialDecimateStrategy"
+scout_compute_api_SpatialDecimateStrategy.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_StabilityDetectionRanges(ConjureBeanType):
     """
     Outputs a set of ranges where the input series is stable. For each point, the min and max are calculated over 
@@ -37749,6 +38191,55 @@ scout_compute_api_SummarizeCartesian.__qualname__ = "SummarizeCartesian"
 scout_compute_api_SummarizeCartesian.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_SummarizeCartesian3d(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'input': ConjureFieldDefinition('input', scout_compute_api_Cartesian3d),
+            'bounds': ConjureFieldDefinition('bounds', OptionalTypeWrapper[scout_compute_api_Cartesian3dBounds]),
+            'max_points': ConjureFieldDefinition('maxPoints', OptionalTypeWrapper[int]),
+            'summarization_strategy': ConjureFieldDefinition('summarizationStrategy', OptionalTypeWrapper[scout_compute_api_ScatterSummarizationStrategy])
+        }
+
+    __slots__: List[str] = ['_input', '_bounds', '_max_points', '_summarization_strategy']
+
+    def __init__(self, input: "scout_compute_api_Cartesian3d", bounds: Optional["scout_compute_api_Cartesian3dBounds"] = None, max_points: Optional[int] = None, summarization_strategy: Optional["scout_compute_api_ScatterSummarizationStrategy"] = None) -> None:
+        self._input = input
+        self._bounds = bounds
+        self._max_points = max_points
+        self._summarization_strategy = summarization_strategy
+
+    @builtins.property
+    def input(self) -> "scout_compute_api_Cartesian3d":
+        return self._input
+
+    @builtins.property
+    def bounds(self) -> Optional["scout_compute_api_Cartesian3dBounds"]:
+        return self._bounds
+
+    @builtins.property
+    def max_points(self) -> Optional[int]:
+        """
+        The maximum number of points to return in the response.
+If more points are found, a BucketedCartesian3dPlot will be returned.
+Maximum is 10,000. Defaults to 2,000 if not specified.
+        """
+        return self._max_points
+
+    @builtins.property
+    def summarization_strategy(self) -> Optional["scout_compute_api_ScatterSummarizationStrategy"]:
+        """
+        The strategy to use when summarizing the series. Only spatial decimation is supported.
+        """
+        return self._summarization_strategy
+
+
+scout_compute_api_SummarizeCartesian3d.__name__ = "SummarizeCartesian3d"
+scout_compute_api_SummarizeCartesian3d.__qualname__ = "SummarizeCartesian3d"
+scout_compute_api_SummarizeCartesian3d.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_SummarizeGeo(ConjureBeanType):
 
     @builtins.classmethod
@@ -41984,6 +42475,115 @@ scout_compute_resolved_api_BitOperationSeriesNode.__qualname__ = "BitOperationSe
 scout_compute_resolved_api_BitOperationSeriesNode.__module__ = "nominal_api.scout_compute_resolved_api"
 
 
+class scout_compute_resolved_api_Cartesian3dBounds(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'min_x': ConjureFieldDefinition('minX', float),
+            'max_x': ConjureFieldDefinition('maxX', float),
+            'min_y': ConjureFieldDefinition('minY', float),
+            'max_y': ConjureFieldDefinition('maxY', float),
+            'min_z': ConjureFieldDefinition('minZ', float),
+            'max_z': ConjureFieldDefinition('maxZ', float)
+        }
+
+    __slots__: List[str] = ['_min_x', '_max_x', '_min_y', '_max_y', '_min_z', '_max_z']
+
+    def __init__(self, max_x: float, max_y: float, max_z: float, min_x: float, min_y: float, min_z: float) -> None:
+        self._min_x = min_x
+        self._max_x = max_x
+        self._min_y = min_y
+        self._max_y = max_y
+        self._min_z = min_z
+        self._max_z = max_z
+
+    @builtins.property
+    def min_x(self) -> float:
+        return self._min_x
+
+    @builtins.property
+    def max_x(self) -> float:
+        return self._max_x
+
+    @builtins.property
+    def min_y(self) -> float:
+        return self._min_y
+
+    @builtins.property
+    def max_y(self) -> float:
+        return self._max_y
+
+    @builtins.property
+    def min_z(self) -> float:
+        return self._min_z
+
+    @builtins.property
+    def max_z(self) -> float:
+        return self._max_z
+
+
+scout_compute_resolved_api_Cartesian3dBounds.__name__ = "Cartesian3dBounds"
+scout_compute_resolved_api_Cartesian3dBounds.__qualname__ = "Cartesian3dBounds"
+scout_compute_resolved_api_Cartesian3dBounds.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
+class scout_compute_resolved_api_Cartesian3dNode(ConjureUnionType):
+    _scatter3d: Optional["scout_compute_resolved_api_Scatter3dNode"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'scatter3d': ConjureFieldDefinition('scatter3d', scout_compute_resolved_api_Scatter3dNode)
+        }
+
+    def __init__(
+            self,
+            scatter3d: Optional["scout_compute_resolved_api_Scatter3dNode"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (scatter3d is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if scatter3d is not None:
+                self._scatter3d = scatter3d
+                self._type = 'scatter3d'
+
+        elif type_of_union == 'scatter3d':
+            if scatter3d is None:
+                raise ValueError('a union value must not be None')
+            self._scatter3d = scatter3d
+            self._type = 'scatter3d'
+
+    @builtins.property
+    def scatter3d(self) -> Optional["scout_compute_resolved_api_Scatter3dNode"]:
+        return self._scatter3d
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_compute_resolved_api_Cartesian3dNodeVisitor):
+            raise ValueError('{} is not an instance of scout_compute_resolved_api_Cartesian3dNodeVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'scatter3d' and self.scatter3d is not None:
+            return visitor._scatter3d(self.scatter3d)
+
+
+scout_compute_resolved_api_Cartesian3dNode.__name__ = "Cartesian3dNode"
+scout_compute_resolved_api_Cartesian3dNode.__qualname__ = "Cartesian3dNode"
+scout_compute_resolved_api_Cartesian3dNode.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
+class scout_compute_resolved_api_Cartesian3dNodeVisitor:
+
+    @abstractmethod
+    def _scatter3d(self, scatter3d: "scout_compute_resolved_api_Scatter3dNode") -> Any:
+        pass
+
+
+scout_compute_resolved_api_Cartesian3dNodeVisitor.__name__ = "Cartesian3dNodeVisitor"
+scout_compute_resolved_api_Cartesian3dNodeVisitor.__qualname__ = "Cartesian3dNodeVisitor"
+scout_compute_resolved_api_Cartesian3dNodeVisitor.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
 class scout_compute_resolved_api_CartesianBounds(ConjureBeanType):
     """
     Min/max bounds of an XY Cartesian plot, inclusive.
@@ -45119,6 +45719,7 @@ class scout_compute_resolved_api_ResolvedNode(ConjureUnionType):
     _series: Optional["scout_compute_resolved_api_SummarizeSeriesNode"] = None
     _value: Optional["scout_compute_resolved_api_SelectValueNode"] = None
     _cartesian: Optional["scout_compute_resolved_api_SummarizeCartesianNode"] = None
+    _cartesian3d: Optional["scout_compute_resolved_api_SummarizeCartesian3dNode"] = None
     _frequency: Optional["scout_compute_resolved_api_FrequencyDomainNode"] = None
     _histogram: Optional["scout_compute_resolved_api_HistogramNode"] = None
     _geo: Optional["scout_compute_resolved_api_SummarizeGeoNode"] = None
@@ -45130,6 +45731,7 @@ class scout_compute_resolved_api_ResolvedNode(ConjureUnionType):
             'series': ConjureFieldDefinition('series', scout_compute_resolved_api_SummarizeSeriesNode),
             'value': ConjureFieldDefinition('value', scout_compute_resolved_api_SelectValueNode),
             'cartesian': ConjureFieldDefinition('cartesian', scout_compute_resolved_api_SummarizeCartesianNode),
+            '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)
@@ -45141,13 +45743,14 @@ class scout_compute_resolved_api_ResolvedNode(ConjureUnionType):
             series: Optional["scout_compute_resolved_api_SummarizeSeriesNode"] = None,
             value: Optional["scout_compute_resolved_api_SelectValueNode"] = None,
             cartesian: Optional["scout_compute_resolved_api_SummarizeCartesianNode"] = None,
+            cartesian3d: Optional["scout_compute_resolved_api_SummarizeCartesian3dNode"] = None,
             frequency: Optional["scout_compute_resolved_api_FrequencyDomainNode"] = None,
             histogram: Optional["scout_compute_resolved_api_HistogramNode"] = None,
             geo: Optional["scout_compute_resolved_api_SummarizeGeoNode"] = 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) + (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) != 1:
                 raise ValueError('a union must contain a single member')
 
             if ranges is not None:
@@ -45162,6 +45765,9 @@ class scout_compute_resolved_api_ResolvedNode(ConjureUnionType):
             if cartesian is not None:
                 self._cartesian = cartesian
                 self._type = 'cartesian'
+            if cartesian3d is not None:
+                self._cartesian3d = cartesian3d
+                self._type = 'cartesian3d'
             if frequency is not None:
                 self._frequency = frequency
                 self._type = 'frequency'
@@ -45192,6 +45798,11 @@ class scout_compute_resolved_api_ResolvedNode(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._cartesian = cartesian
             self._type = 'cartesian'
+        elif type_of_union == 'cartesian3d':
+            if cartesian3d is None:
+                raise ValueError('a union value must not be None')
+            self._cartesian3d = cartesian3d
+            self._type = 'cartesian3d'
         elif type_of_union == 'frequency':
             if frequency is None:
                 raise ValueError('a union value must not be None')
@@ -45224,6 +45835,10 @@ class scout_compute_resolved_api_ResolvedNode(ConjureUnionType):
     def cartesian(self) -> Optional["scout_compute_resolved_api_SummarizeCartesianNode"]:
         return self._cartesian
 
+    @builtins.property
+    def cartesian3d(self) -> Optional["scout_compute_resolved_api_SummarizeCartesian3dNode"]:
+        return self._cartesian3d
+
     @builtins.property
     def frequency(self) -> Optional["scout_compute_resolved_api_FrequencyDomainNode"]:
         return self._frequency
@@ -45247,6 +45862,8 @@ class scout_compute_resolved_api_ResolvedNode(ConjureUnionType):
             return visitor._value(self.value)
         if self._type == 'cartesian' and self.cartesian is not None:
             return visitor._cartesian(self.cartesian)
+        if self._type == 'cartesian3d' and self.cartesian3d is not None:
+            return visitor._cartesian3d(self.cartesian3d)
         if self._type == 'frequency' and self.frequency is not None:
             return visitor._frequency(self.frequency)
         if self._type == 'histogram' and self.histogram is not None:
@@ -45278,6 +45895,10 @@ class scout_compute_resolved_api_ResolvedNodeVisitor:
     def _cartesian(self, cartesian: "scout_compute_resolved_api_SummarizeCartesianNode") -> Any:
         pass
 
+    @abstractmethod
+    def _cartesian3d(self, cartesian3d: "scout_compute_resolved_api_SummarizeCartesian3dNode") -> Any:
+        pass
+
     @abstractmethod
     def _frequency(self, frequency: "scout_compute_resolved_api_FrequencyDomainNode") -> Any:
         pass
@@ -45366,6 +45987,47 @@ scout_compute_resolved_api_ScaleSeriesNode.__qualname__ = "ScaleSeriesNode"
 scout_compute_resolved_api_ScaleSeriesNode.__module__ = "nominal_api.scout_compute_resolved_api"
 
 
+class scout_compute_resolved_api_Scatter3dNode(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'x': ConjureFieldDefinition('x', scout_compute_resolved_api_NumericSeriesNode),
+            'y': ConjureFieldDefinition('y', scout_compute_resolved_api_NumericSeriesNode),
+            'z': ConjureFieldDefinition('z', scout_compute_resolved_api_NumericSeriesNode),
+            'driver_series': ConjureFieldDefinition('driverSeries', scout_compute_api_DriverSeries3d)
+        }
+
+    __slots__: List[str] = ['_x', '_y', '_z', '_driver_series']
+
+    def __init__(self, driver_series: "scout_compute_api_DriverSeries3d", x: "scout_compute_resolved_api_NumericSeriesNode", y: "scout_compute_resolved_api_NumericSeriesNode", z: "scout_compute_resolved_api_NumericSeriesNode") -> None:
+        self._x = x
+        self._y = y
+        self._z = z
+        self._driver_series = driver_series
+
+    @builtins.property
+    def x(self) -> "scout_compute_resolved_api_NumericSeriesNode":
+        return self._x
+
+    @builtins.property
+    def y(self) -> "scout_compute_resolved_api_NumericSeriesNode":
+        return self._y
+
+    @builtins.property
+    def z(self) -> "scout_compute_resolved_api_NumericSeriesNode":
+        return self._z
+
+    @builtins.property
+    def driver_series(self) -> "scout_compute_api_DriverSeries3d":
+        return self._driver_series
+
+
+scout_compute_resolved_api_Scatter3dNode.__name__ = "Scatter3dNode"
+scout_compute_resolved_api_Scatter3dNode.__qualname__ = "Scatter3dNode"
+scout_compute_resolved_api_Scatter3dNode.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
 class scout_compute_resolved_api_ScatterNode(ConjureBeanType):
 
     @builtins.classmethod
@@ -45915,6 +46577,47 @@ scout_compute_resolved_api_SumSeriesNode.__qualname__ = "SumSeriesNode"
 scout_compute_resolved_api_SumSeriesNode.__module__ = "nominal_api.scout_compute_resolved_api"
 
 
+class scout_compute_resolved_api_SummarizeCartesian3dNode(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'input': ConjureFieldDefinition('input', scout_compute_resolved_api_Cartesian3dNode),
+            'bounds': ConjureFieldDefinition('bounds', OptionalTypeWrapper[scout_compute_resolved_api_Cartesian3dBounds]),
+            'max_points': ConjureFieldDefinition('maxPoints', OptionalTypeWrapper[int]),
+            'summarization_strategy': ConjureFieldDefinition('summarizationStrategy', scout_compute_api_ScatterSummarizationStrategy)
+        }
+
+    __slots__: List[str] = ['_input', '_bounds', '_max_points', '_summarization_strategy']
+
+    def __init__(self, input: "scout_compute_resolved_api_Cartesian3dNode", summarization_strategy: "scout_compute_api_ScatterSummarizationStrategy", bounds: Optional["scout_compute_resolved_api_Cartesian3dBounds"] = None, max_points: Optional[int] = None) -> None:
+        self._input = input
+        self._bounds = bounds
+        self._max_points = max_points
+        self._summarization_strategy = summarization_strategy
+
+    @builtins.property
+    def input(self) -> "scout_compute_resolved_api_Cartesian3dNode":
+        return self._input
+
+    @builtins.property
+    def bounds(self) -> Optional["scout_compute_resolved_api_Cartesian3dBounds"]:
+        return self._bounds
+
+    @builtins.property
+    def max_points(self) -> Optional[int]:
+        return self._max_points
+
+    @builtins.property
+    def summarization_strategy(self) -> "scout_compute_api_ScatterSummarizationStrategy":
+        return self._summarization_strategy
+
+
+scout_compute_resolved_api_SummarizeCartesian3dNode.__name__ = "SummarizeCartesian3dNode"
+scout_compute_resolved_api_SummarizeCartesian3dNode.__qualname__ = "SummarizeCartesian3dNode"
+scout_compute_resolved_api_SummarizeCartesian3dNode.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
 class scout_compute_resolved_api_SummarizeCartesianNode(ConjureBeanType):
 
     @builtins.classmethod

nominal_api/scout_compute_api/__init__.py

@@ -25,12 +25,18 @@ from .._impl import (
     scout_compute_api_BitOrFunction as BitOrFunction,
     scout_compute_api_BitTestFunction as BitTestFunction,
     scout_compute_api_BitXorFunction as BitXorFunction,
+    scout_compute_api_BucketedCartesian3dPlot as BucketedCartesian3dPlot,
     scout_compute_api_BucketedCartesianPlot as BucketedCartesianPlot,
     scout_compute_api_BucketedEnumPlot as BucketedEnumPlot,
     scout_compute_api_BucketedGeoPlot as BucketedGeoPlot,
     scout_compute_api_BucketedGeoPlotVisitor as BucketedGeoPlotVisitor,
     scout_compute_api_BucketedNumericPlot as BucketedNumericPlot,
     scout_compute_api_Cartesian as Cartesian,
+    scout_compute_api_Cartesian3d as Cartesian3d,
+    scout_compute_api_Cartesian3dBounds as Cartesian3dBounds,
+    scout_compute_api_Cartesian3dBucket as Cartesian3dBucket,
+    scout_compute_api_Cartesian3dUnitResult as Cartesian3dUnitResult,
+    scout_compute_api_Cartesian3dVisitor as Cartesian3dVisitor,
     scout_compute_api_CartesianBounds as CartesianBounds,
     scout_compute_api_CartesianBucket as CartesianBucket,
     scout_compute_api_CartesianPlot as CartesianPlot,
@@ -68,6 +74,7 @@ from .._impl import (
     scout_compute_api_DerivativeSeries as DerivativeSeries,
     scout_compute_api_DoubleConstant as DoubleConstant,
     scout_compute_api_DoubleConstantVisitor as DoubleConstantVisitor,
+    scout_compute_api_DriverSeries3d as DriverSeries3d,
     scout_compute_api_DurationConstant as DurationConstant,
     scout_compute_api_DurationConstantVisitor as DurationConstantVisitor,
     scout_compute_api_EnumAggregationFunction as EnumAggregationFunction,
@@ -215,6 +222,9 @@ from .._impl import (
     scout_compute_api_RunChannel as RunChannel,
     scout_compute_api_ScaleSeries as ScaleSeries,
     scout_compute_api_Scatter as Scatter,
+    scout_compute_api_Scatter3d as Scatter3d,
+    scout_compute_api_ScatterSummarizationStrategy as ScatterSummarizationStrategy,
+    scout_compute_api_ScatterSummarizationStrategyVisitor as ScatterSummarizationStrategyVisitor,
     scout_compute_api_SelectValue as SelectValue,
     scout_compute_api_SelectValueVisitor as SelectValueVisitor,
     scout_compute_api_Series as Series,
@@ -227,6 +237,7 @@ from .._impl import (
     scout_compute_api_SignalFilterConfiguration as SignalFilterConfiguration,
     scout_compute_api_SignalFilterConfigurationVisitor as SignalFilterConfigurationVisitor,
     scout_compute_api_SignalFilterSeries as SignalFilterSeries,
+    scout_compute_api_SpatialDecimateStrategy as SpatialDecimateStrategy,
     scout_compute_api_StabilityDetectionRanges as StabilityDetectionRanges,
     scout_compute_api_StabilityWindowConfiguration as StabilityWindowConfiguration,
     scout_compute_api_StaleRanges as StaleRanges,
@@ -240,6 +251,7 @@ from .._impl import (
     scout_compute_api_SummarizationStrategy as SummarizationStrategy,
     scout_compute_api_SummarizationStrategyVisitor as SummarizationStrategyVisitor,
     scout_compute_api_SummarizeCartesian as SummarizeCartesian,
+    scout_compute_api_SummarizeCartesian3d as SummarizeCartesian3d,
     scout_compute_api_SummarizeGeo as SummarizeGeo,
     scout_compute_api_SummarizeRanges as SummarizeRanges,
     scout_compute_api_SummarizeSeries as SummarizeSeries,

nominal_api/scout_compute_resolved_api/__init__.py

@@ -8,6 +8,9 @@ from .._impl import (
     scout_compute_resolved_api_BandStopConfiguration as BandStopConfiguration,
     scout_compute_resolved_api_BinaryArithmeticSeriesNode as BinaryArithmeticSeriesNode,
     scout_compute_resolved_api_BitOperationSeriesNode as BitOperationSeriesNode,
+    scout_compute_resolved_api_Cartesian3dBounds as Cartesian3dBounds,
+    scout_compute_resolved_api_Cartesian3dNode as Cartesian3dNode,
+    scout_compute_resolved_api_Cartesian3dNodeVisitor as Cartesian3dNodeVisitor,
     scout_compute_resolved_api_CartesianBounds as CartesianBounds,
     scout_compute_resolved_api_CartesianNode as CartesianNode,
     scout_compute_resolved_api_CartesianNodeVisitor as CartesianNodeVisitor,
@@ -85,6 +88,7 @@ from .._impl import (
     scout_compute_resolved_api_ResolvedNodeVisitor as ResolvedNodeVisitor,
     scout_compute_resolved_api_RollingOperationSeriesNode as RollingOperationSeriesNode,
     scout_compute_resolved_api_ScaleSeriesNode as ScaleSeriesNode,
+    scout_compute_resolved_api_Scatter3dNode as Scatter3dNode,
     scout_compute_resolved_api_ScatterNode as ScatterNode,
     scout_compute_resolved_api_SelectValueNode as SelectValueNode,
     scout_compute_resolved_api_SelectValueNodeVisitor as SelectValueNodeVisitor,
@@ -97,6 +101,7 @@ from .._impl import (
     scout_compute_resolved_api_StabilityDetectionRangesNode as StabilityDetectionRangesNode,
     scout_compute_resolved_api_StaleRangesNode as StaleRangesNode,
     scout_compute_resolved_api_SumSeriesNode as SumSeriesNode,
+    scout_compute_resolved_api_SummarizeCartesian3dNode as SummarizeCartesian3dNode,
     scout_compute_resolved_api_SummarizeCartesianNode as SummarizeCartesianNode,
     scout_compute_resolved_api_SummarizeGeoNode as SummarizeGeoNode,
     scout_compute_resolved_api_SummarizeRangesNode as SummarizeRangesNode,

{nominal_api-0.569.1.dist-info → nominal_api-0.571.0.dist-info}/METADATA

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

{nominal_api-0.569.1.dist-info → nominal_api-0.571.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
-nominal_api/__init__.py,sha256=uvercar1Xvd_uQ58khAkL-gB_uZtDTZEJRxZNojo-0M,1823
-nominal_api/_impl.py,sha256=djsIvJ4QU-gNvNLO12qPX7cuHkHvIOmPmlgvMd8szS4,2768631
+nominal_api/__init__.py,sha256=acep2BwCp-3yYQnYdCFWELpzkQyUov-ngNwbyxkNq8Q,1823
+nominal_api/_impl.py,sha256=T2aMV_ZvPAVewNOeikOpbo8tmFytoSSrKMuR540IT1I,2796554
 nominal_api/py.typed,sha256=eoZ6GfifbqhMLNzjlqRDVil-yyBkOmVN9ujSgJWNBlY,15
 nominal_api/api/__init__.py,sha256=kJBEE_HLVpKYdLH12KyO-cSAVzwxYpBwaaDutCtT-LM,1236
 nominal_api/api_rids/__init__.py,sha256=Bu-pKUh3aS9_f5m-DZf6W_BUlVo9qYE7EDvaT-rvWQ0,423
@@ -27,10 +27,10 @@ nominal_api/scout_checklistexecution_api/__init__.py,sha256=FPiuWjrlG5wLVbd7KE7M
 nominal_api/scout_checks_api/__init__.py,sha256=RJH7HsXjUhItC11V9C-hfv6lkIfiSXyxnB8slUpaT2g,5203
 nominal_api/scout_comparisonnotebook_api/__init__.py,sha256=8BL5jE9NDxqCj9DyvZWSPhq6zw2J7xp6aLsl3x9rpyw,4530
 nominal_api/scout_comparisonrun_api/__init__.py,sha256=1LCXQe64tDqqeMQixW8PI-R_edSz7F5X0x2_ufEuC8M,480
-nominal_api/scout_compute_api/__init__.py,sha256=DGXb6TQbX4DklA6W6rTqPqkU2W5KdmsO1xZBD2MdFXA,17216
+nominal_api/scout_compute_api/__init__.py,sha256=B2yz-tKnA6_EclHLOHBAax2mccXfueBYtGVmASrBfCI,18024
 nominal_api/scout_compute_api_deprecated/__init__.py,sha256=RggSfc6C1VR1-kNXPWybpfw3hZbkQ1gvxEisFZCHdnM,3732
 nominal_api/scout_compute_representation_api/__init__.py,sha256=FezODo7sI8m6tDhPPK_gZX1qXImi4O3TUprDoNUuWpk,1672
-nominal_api/scout_compute_resolved_api/__init__.py,sha256=-IZ6eqgHGJsK3Z2URCYUlUgoyghlSMT2Ml7xJjmJePs,8698
+nominal_api/scout_compute_resolved_api/__init__.py,sha256=ptE3Q2eYAr9h0m6Gq3X7uGNQmur8K2ELIvvnU8FXZw0,9065
 nominal_api/scout_dataexport_api/__init__.py,sha256=pWRQdQJOObD0jITRYLw3AxeDJSrJQqAdFZACxULqA4o,1487
 nominal_api/scout_datareview_api/__init__.py,sha256=ETAl7VWaxOk8g9uwfsKo573-3qfDNbGQ1_QBQaDPRxk,8405
 nominal_api/scout_datasource/__init__.py,sha256=1NWMrEx-JOEb4Pmd2oAqcpSmQB3g3lxgxFenWEtcF2M,101
@@ -67,7 +67,7 @@ nominal_api/timeseries_logicalseries_api/__init__.py,sha256=7NlQhIzOKOcjwMNUI89f
 nominal_api/timeseries_seriescache/__init__.py,sha256=tFCkNuyrVMgtj-HIl1pOYPJHaL2VikI4C_x97bX_Lcs,109
 nominal_api/timeseries_seriescache_api/__init__.py,sha256=U9EhlqdF9qzD1O9al0vcvcdgS_C5lq-lN3Kmr0K3g84,1191
 nominal_api/upload_api/__init__.py,sha256=ZMudWMSqCrNozohbHaJKuxJnT9Edepe7nxxXMz_pT9k,87
-nominal_api-0.569.1.dist-info/METADATA,sha256=16-Mk4w03EWky6aTlNujrEj_Fn6fqXlhHjucIBO3sks,199
-nominal_api-0.569.1.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-nominal_api-0.569.1.dist-info/top_level.txt,sha256=gI1ZdNJbuHcJZeKtCzzBXsEtpU1GX6XJKs6ksi_gCRA,12
-nominal_api-0.569.1.dist-info/RECORD,,
+nominal_api-0.571.0.dist-info/METADATA,sha256=dmGfOYgNG-FwJGzDUFFUmEKVWEb_2-QTplNbin6b6SE,199
+nominal_api-0.571.0.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
+nominal_api-0.571.0.dist-info/top_level.txt,sha256=gI1ZdNJbuHcJZeKtCzzBXsEtpU1GX6XJKs6ksi_gCRA,12
+nominal_api-0.571.0.dist-info/RECORD,,