nominal-api 0.977.0__tar.gz → 0.978.0__tar.gz

{nominal_api-0.977.0 → nominal_api-0.978.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nominal-api
-Version: 0.977.0
+Version: 0.978.0
 Requires-Python: >=3.8
 Requires-Dist: requests
 Requires-Dist: conjure-python-client<4,>=2.8.0

{nominal_api-0.977.0 → nominal_api-0.978.0}/nominal_api/__init__.py

@@ -82,5 +82,5 @@ __all__ = [
 
 __conjure_generator_version__ = "4.17.0"
 
-__version__ = "0.977.0"
+__version__ = "0.978.0"
 

{nominal_api-0.977.0 → nominal_api-0.978.0}/nominal_api/_impl.py

@@ -554,6 +554,8 @@ class api_SeriesDataType(ConjureEnumType):
     '''DOUBLE_ARRAY'''
     STRING_ARRAY = 'STRING_ARRAY'
     '''STRING_ARRAY'''
+    STRUCT = 'STRUCT'
+    '''STRUCT'''
     UNKNOWN = 'UNKNOWN'
     '''UNKNOWN'''
 
@@ -6142,6 +6144,52 @@ event_AssigneesFilter.__qualname__ = "AssigneesFilter"
 event_AssigneesFilter.__module__ = "nominal_api.event"
 
 
+class event_BatchAggregateEventsRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'requests': ConjureFieldDefinition('requests', List[event_AggregateEventsRequest])
+        }
+
+    __slots__: List[str] = ['_requests']
+
+    def __init__(self, requests: List["event_AggregateEventsRequest"]) -> None:
+        self._requests = requests
+
+    @builtins.property
+    def requests(self) -> List["event_AggregateEventsRequest"]:
+        return self._requests
+
+
+event_BatchAggregateEventsRequest.__name__ = "BatchAggregateEventsRequest"
+event_BatchAggregateEventsRequest.__qualname__ = "BatchAggregateEventsRequest"
+event_BatchAggregateEventsRequest.__module__ = "nominal_api.event"
+
+
+class event_BatchAggregateEventsResponse(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'responses': ConjureFieldDefinition('responses', List[event_AggregateEventsResponse])
+        }
+
+    __slots__: List[str] = ['_responses']
+
+    def __init__(self, responses: List["event_AggregateEventsResponse"]) -> None:
+        self._responses = responses
+
+    @builtins.property
+    def responses(self) -> List["event_AggregateEventsResponse"]:
+        return self._responses
+
+
+event_BatchAggregateEventsResponse.__name__ = "BatchAggregateEventsResponse"
+event_BatchAggregateEventsResponse.__qualname__ = "BatchAggregateEventsResponse"
+event_BatchAggregateEventsResponse.__module__ = "nominal_api.event"
+
+
 class event_BatchUpdateDispositionRequest(ConjureBeanType):
 
     @builtins.classmethod
@@ -7113,6 +7161,39 @@ Empty fields in the UpdateEventRequest are left unchanged.
         _decoder = ConjureDecoder()
         return _decoder.decode(_response.json(), event_AggregateEventsResponse, self._return_none_for_unknown_union_types)
 
+    def batch_aggregate_events(self, auth_header: str, request: "event_BatchAggregateEventsRequest") -> "event_BatchAggregateEventsResponse":
+        """Searches for events matching the given filter and aggregates them based on the requested functions.
+Returns a list of responses in same order as the batched requests.
+        """
+        _conjure_encoder = ConjureEncoder()
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, str] = {
+        }
+
+        _json: Any = _conjure_encoder.default(request)
+
+        _path = '/event/v1/aggregate-events/batch'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'POST',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        _decoder = ConjureDecoder()
+        return _decoder.decode(_response.json(), event_BatchAggregateEventsResponse, self._return_none_for_unknown_union_types)
+
     def get_events_histogram(self, auth_header: str, request: "event_EventsHistogramRequest") -> "event_EventsHistogramResponse":
         """Gets a histogram of events that match the given filters.
         """
@@ -44053,6 +44134,7 @@ class scout_compute_api_ComputeNode(ConjureUnionType):
     _log: Optional["scout_compute_api_LogSeries"] = None
     _ranges: Optional["scout_compute_api_RangeSeries"] = None
     _array: Optional["scout_compute_api_ArraySeries"] = None
+    _struct: Optional["scout_compute_api_StructSeries"] = None
     _curve_fit: Optional["scout_compute_api_CurveFit"] = None
     _raw: Optional["scout_compute_api_Reference"] = None
 
@@ -44064,6 +44146,7 @@ class scout_compute_api_ComputeNode(ConjureUnionType):
             'log': ConjureFieldDefinition('log', scout_compute_api_LogSeries),
             'ranges': ConjureFieldDefinition('ranges', scout_compute_api_RangeSeries),
             'array': ConjureFieldDefinition('array', scout_compute_api_ArraySeries),
+            'struct': ConjureFieldDefinition('struct', scout_compute_api_StructSeries),
             'curve_fit': ConjureFieldDefinition('curveFit', scout_compute_api_CurveFit),
             'raw': ConjureFieldDefinition('raw', scout_compute_api_Reference)
         }
@@ -44075,12 +44158,13 @@ class scout_compute_api_ComputeNode(ConjureUnionType):
             log: Optional["scout_compute_api_LogSeries"] = None,
             ranges: Optional["scout_compute_api_RangeSeries"] = None,
             array: Optional["scout_compute_api_ArraySeries"] = None,
+            struct: Optional["scout_compute_api_StructSeries"] = None,
             curve_fit: Optional["scout_compute_api_CurveFit"] = None,
             raw: Optional["scout_compute_api_Reference"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (enum is not None) + (numeric is not None) + (log is not None) + (ranges is not None) + (array is not None) + (curve_fit is not None) + (raw is not None) != 1:
+            if (enum is not None) + (numeric is not None) + (log is not None) + (ranges is not None) + (array is not None) + (struct is not None) + (curve_fit is not None) + (raw is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if enum is not None:
@@ -44098,6 +44182,9 @@ class scout_compute_api_ComputeNode(ConjureUnionType):
             if array is not None:
                 self._array = array
                 self._type = 'array'
+            if struct is not None:
+                self._struct = struct
+                self._type = 'struct'
             if curve_fit is not None:
                 self._curve_fit = curve_fit
                 self._type = 'curveFit'
@@ -44130,6 +44217,11 @@ class scout_compute_api_ComputeNode(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._array = array
             self._type = 'array'
+        elif type_of_union == 'struct':
+            if struct is None:
+                raise ValueError('a union value must not be None')
+            self._struct = struct
+            self._type = 'struct'
         elif type_of_union == 'curveFit':
             if curve_fit is None:
                 raise ValueError('a union value must not be None')
@@ -44161,6 +44253,10 @@ class scout_compute_api_ComputeNode(ConjureUnionType):
     def array(self) -> Optional["scout_compute_api_ArraySeries"]:
         return self._array
 
+    @builtins.property
+    def struct(self) -> Optional["scout_compute_api_StructSeries"]:
+        return self._struct
+
     @builtins.property
     def curve_fit(self) -> Optional["scout_compute_api_CurveFit"]:
         return self._curve_fit
@@ -44182,6 +44278,8 @@ class scout_compute_api_ComputeNode(ConjureUnionType):
             return visitor._ranges(self.ranges)
         if self._type == 'array' and self.array is not None:
             return visitor._array(self.array)
+        if self._type == 'struct' and self.struct is not None:
+            return visitor._struct(self.struct)
         if self._type == 'curveFit' and self.curve_fit is not None:
             return visitor._curve_fit(self.curve_fit)
         if self._type == 'raw' and self.raw is not None:
@@ -44215,6 +44313,10 @@ class scout_compute_api_ComputeNodeVisitor:
     def _array(self, array: "scout_compute_api_ArraySeries") -> Any:
         pass
 
+    @abstractmethod
+    def _struct(self, struct: "scout_compute_api_StructSeries") -> Any:
+        pass
+
     @abstractmethod
     def _curve_fit(self, curve_fit: "scout_compute_api_CurveFit") -> Any:
         pass
@@ -54701,6 +54803,7 @@ class scout_compute_api_Series(ConjureUnionType):
     _numeric: Optional["scout_compute_api_NumericSeries"] = None
     _log: Optional["scout_compute_api_LogSeries"] = None
     _array: Optional["scout_compute_api_ArraySeries"] = None
+    _struct: Optional["scout_compute_api_StructSeries"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
@@ -54709,7 +54812,8 @@ class scout_compute_api_Series(ConjureUnionType):
             'enum': ConjureFieldDefinition('enum', scout_compute_api_EnumSeries),
             'numeric': ConjureFieldDefinition('numeric', scout_compute_api_NumericSeries),
             'log': ConjureFieldDefinition('log', scout_compute_api_LogSeries),
-            'array': ConjureFieldDefinition('array', scout_compute_api_ArraySeries)
+            'array': ConjureFieldDefinition('array', scout_compute_api_ArraySeries),
+            'struct': ConjureFieldDefinition('struct', scout_compute_api_StructSeries)
         }
 
     def __init__(
@@ -54719,10 +54823,11 @@ class scout_compute_api_Series(ConjureUnionType):
             numeric: Optional["scout_compute_api_NumericSeries"] = None,
             log: Optional["scout_compute_api_LogSeries"] = None,
             array: Optional["scout_compute_api_ArraySeries"] = None,
+            struct: Optional["scout_compute_api_StructSeries"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (raw is not None) + (enum is not None) + (numeric is not None) + (log is not None) + (array is not None) != 1:
+            if (raw is not None) + (enum is not None) + (numeric is not None) + (log is not None) + (array is not None) + (struct is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if raw is not None:
@@ -54740,6 +54845,9 @@ class scout_compute_api_Series(ConjureUnionType):
             if array is not None:
                 self._array = array
                 self._type = 'array'
+            if struct is not None:
+                self._struct = struct
+                self._type = 'struct'
 
         elif type_of_union == 'raw':
             if raw is None:
@@ -54766,6 +54874,11 @@ class scout_compute_api_Series(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._array = array
             self._type = 'array'
+        elif type_of_union == 'struct':
+            if struct is None:
+                raise ValueError('a union value must not be None')
+            self._struct = struct
+            self._type = 'struct'
 
     @builtins.property
     def raw(self) -> Optional["scout_compute_api_Reference"]:
@@ -54787,6 +54900,10 @@ class scout_compute_api_Series(ConjureUnionType):
     def array(self) -> Optional["scout_compute_api_ArraySeries"]:
         return self._array
 
+    @builtins.property
+    def struct(self) -> Optional["scout_compute_api_StructSeries"]:
+        return self._struct
+
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, scout_compute_api_SeriesVisitor):
             raise ValueError('{} is not an instance of scout_compute_api_SeriesVisitor'.format(visitor.__class__.__name__))
@@ -54800,6 +54917,8 @@ class scout_compute_api_Series(ConjureUnionType):
             return visitor._log(self.log)
         if self._type == 'array' and self.array is not None:
             return visitor._array(self.array)
+        if self._type == 'struct' and self.struct is not None:
+            return visitor._struct(self.struct)
 
 
 scout_compute_api_Series.__name__ = "Series"
@@ -54829,6 +54948,10 @@ class scout_compute_api_SeriesVisitor:
     def _array(self, array: "scout_compute_api_ArraySeries") -> Any:
         pass
 
+    @abstractmethod
+    def _struct(self, struct: "scout_compute_api_StructSeries") -> Any:
+        pass
+
 
 scout_compute_api_SeriesVisitor.__name__ = "SeriesVisitor"
 scout_compute_api_SeriesVisitor.__qualname__ = "SeriesVisitor"
@@ -55492,6 +55615,104 @@ scout_compute_api_StringSetConstantVisitor.__qualname__ = "StringSetConstantVisi
 scout_compute_api_StringSetConstantVisitor.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_StructSeries(ConjureUnionType):
+    _channel: Optional["scout_compute_api_ChannelSeries"] = None
+    _raw: Optional["scout_compute_api_Reference"] = None
+    _derived: Optional["scout_compute_api_DerivedSeries"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'channel': ConjureFieldDefinition('channel', scout_compute_api_ChannelSeries),
+            'raw': ConjureFieldDefinition('raw', scout_compute_api_Reference),
+            'derived': ConjureFieldDefinition('derived', scout_compute_api_DerivedSeries)
+        }
+
+    def __init__(
+            self,
+            channel: Optional["scout_compute_api_ChannelSeries"] = None,
+            raw: Optional["scout_compute_api_Reference"] = None,
+            derived: Optional["scout_compute_api_DerivedSeries"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (channel is not None) + (raw is not None) + (derived is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if channel is not None:
+                self._channel = channel
+                self._type = 'channel'
+            if raw is not None:
+                self._raw = raw
+                self._type = 'raw'
+            if derived is not None:
+                self._derived = derived
+                self._type = 'derived'
+
+        elif type_of_union == 'channel':
+            if channel is None:
+                raise ValueError('a union value must not be None')
+            self._channel = channel
+            self._type = 'channel'
+        elif type_of_union == 'raw':
+            if raw is None:
+                raise ValueError('a union value must not be None')
+            self._raw = raw
+            self._type = 'raw'
+        elif type_of_union == 'derived':
+            if derived is None:
+                raise ValueError('a union value must not be None')
+            self._derived = derived
+            self._type = 'derived'
+
+    @builtins.property
+    def channel(self) -> Optional["scout_compute_api_ChannelSeries"]:
+        return self._channel
+
+    @builtins.property
+    def raw(self) -> Optional["scout_compute_api_Reference"]:
+        return self._raw
+
+    @builtins.property
+    def derived(self) -> Optional["scout_compute_api_DerivedSeries"]:
+        return self._derived
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_compute_api_StructSeriesVisitor):
+            raise ValueError('{} is not an instance of scout_compute_api_StructSeriesVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'channel' and self.channel is not None:
+            return visitor._channel(self.channel)
+        if self._type == 'raw' and self.raw is not None:
+            return visitor._raw(self.raw)
+        if self._type == 'derived' and self.derived is not None:
+            return visitor._derived(self.derived)
+
+
+scout_compute_api_StructSeries.__name__ = "StructSeries"
+scout_compute_api_StructSeries.__qualname__ = "StructSeries"
+scout_compute_api_StructSeries.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_StructSeriesVisitor:
+
+    @abstractmethod
+    def _channel(self, channel: "scout_compute_api_ChannelSeries") -> Any:
+        pass
+
+    @abstractmethod
+    def _raw(self, raw: "scout_compute_api_Reference") -> Any:
+        pass
+
+    @abstractmethod
+    def _derived(self, derived: "scout_compute_api_DerivedSeries") -> Any:
+        pass
+
+
+scout_compute_api_StructSeriesVisitor.__name__ = "StructSeriesVisitor"
+scout_compute_api_StructSeriesVisitor.__qualname__ = "StructSeriesVisitor"
+scout_compute_api_StructSeriesVisitor.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_Sum(ConjureBeanType):
     """The sum of point values inside the time window.
     """
@@ -56910,7 +57131,7 @@ class scout_compute_api_Value(ConjureUnionType):
     _float64_value: Optional[float] = None
     _int64_value: Optional[str] = None
     _array_value: Optional[List[Optional["scout_compute_api_Value"]]] = None
-    _struct_value: Optional[Dict[str, Optional["scout_compute_api_Value"]]] = None
+    _struct_value: Optional[Any] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
@@ -56919,7 +57140,7 @@ class scout_compute_api_Value(ConjureUnionType):
             'float64_value': ConjureFieldDefinition('float64Value', float),
             'int64_value': ConjureFieldDefinition('int64Value', str),
             'array_value': ConjureFieldDefinition('arrayValue', List[OptionalTypeWrapper[scout_compute_api_Value]]),
-            'struct_value': ConjureFieldDefinition('structValue', Dict[str, OptionalTypeWrapper[scout_compute_api_Value]])
+            'struct_value': ConjureFieldDefinition('structValue', object)
         }
 
     def __init__(
@@ -56928,7 +57149,7 @@ class scout_compute_api_Value(ConjureUnionType):
             float64_value: Optional[float] = None,
             int64_value: Optional[str] = None,
             array_value: Optional[List[Optional["scout_compute_api_Value"]]] = None,
-            struct_value: Optional[Dict[str, Optional["scout_compute_api_Value"]]] = None,
+            struct_value: Optional[Any] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
@@ -56994,7 +57215,9 @@ class scout_compute_api_Value(ConjureUnionType):
         return self._array_value
 
     @builtins.property
-    def struct_value(self) -> Optional[Dict[str, Optional["scout_compute_api_Value"]]]:
+    def struct_value(self) -> Optional[Any]:
+        """A JSON representation of the struct
+        """
         return self._struct_value
 
     def accept(self, visitor) -> Any:
@@ -57036,7 +57259,7 @@ class scout_compute_api_ValueVisitor:
         pass
 
     @abstractmethod
-    def _struct_value(self, struct_value: Dict[str, Optional["scout_compute_api_Value"]]) -> Any:
+    def _struct_value(self, struct_value: Any) -> Any:
         pass
 
 
@@ -65204,6 +65427,7 @@ class scout_compute_resolved_api_SeriesNode(ConjureUnionType):
     _numeric: Optional["scout_compute_resolved_api_NumericSeriesNode"] = None
     _log: Optional["scout_compute_resolved_api_LogSeriesNode"] = None
     _array: Optional["scout_compute_resolved_api_ArraySeriesNode"] = None
+    _struct: Optional["scout_compute_resolved_api_StructSeriesNode"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
@@ -65212,7 +65436,8 @@ class scout_compute_resolved_api_SeriesNode(ConjureUnionType):
             'enum': ConjureFieldDefinition('enum', scout_compute_resolved_api_EnumSeriesNode),
             'numeric': ConjureFieldDefinition('numeric', scout_compute_resolved_api_NumericSeriesNode),
             'log': ConjureFieldDefinition('log', scout_compute_resolved_api_LogSeriesNode),
-            'array': ConjureFieldDefinition('array', scout_compute_resolved_api_ArraySeriesNode)
+            'array': ConjureFieldDefinition('array', scout_compute_resolved_api_ArraySeriesNode),
+            'struct': ConjureFieldDefinition('struct', scout_compute_resolved_api_StructSeriesNode)
         }
 
     def __init__(
@@ -65222,10 +65447,11 @@ class scout_compute_resolved_api_SeriesNode(ConjureUnionType):
             numeric: Optional["scout_compute_resolved_api_NumericSeriesNode"] = None,
             log: Optional["scout_compute_resolved_api_LogSeriesNode"] = None,
             array: Optional["scout_compute_resolved_api_ArraySeriesNode"] = None,
+            struct: Optional["scout_compute_resolved_api_StructSeriesNode"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (raw is not None) + (enum is not None) + (numeric is not None) + (log is not None) + (array is not None) != 1:
+            if (raw is not None) + (enum is not None) + (numeric is not None) + (log is not None) + (array is not None) + (struct is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if raw is not None:
@@ -65243,6 +65469,9 @@ class scout_compute_resolved_api_SeriesNode(ConjureUnionType):
             if array is not None:
                 self._array = array
                 self._type = 'array'
+            if struct is not None:
+                self._struct = struct
+                self._type = 'struct'
 
         elif type_of_union == 'raw':
             if raw is None:
@@ -65269,6 +65498,11 @@ class scout_compute_resolved_api_SeriesNode(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._array = array
             self._type = 'array'
+        elif type_of_union == 'struct':
+            if struct is None:
+                raise ValueError('a union value must not be None')
+            self._struct = struct
+            self._type = 'struct'
 
     @builtins.property
     def raw(self) -> Optional["scout_compute_resolved_api_RawUntypedSeriesNode"]:
@@ -65290,6 +65524,10 @@ class scout_compute_resolved_api_SeriesNode(ConjureUnionType):
     def array(self) -> Optional["scout_compute_resolved_api_ArraySeriesNode"]:
         return self._array
 
+    @builtins.property
+    def struct(self) -> Optional["scout_compute_resolved_api_StructSeriesNode"]:
+        return self._struct
+
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, scout_compute_resolved_api_SeriesNodeVisitor):
             raise ValueError('{} is not an instance of scout_compute_resolved_api_SeriesNodeVisitor'.format(visitor.__class__.__name__))
@@ -65303,6 +65541,8 @@ class scout_compute_resolved_api_SeriesNode(ConjureUnionType):
             return visitor._log(self.log)
         if self._type == 'array' and self.array is not None:
             return visitor._array(self.array)
+        if self._type == 'struct' and self.struct is not None:
+            return visitor._struct(self.struct)
 
 
 scout_compute_resolved_api_SeriesNode.__name__ = "SeriesNode"
@@ -65332,6 +65572,10 @@ class scout_compute_resolved_api_SeriesNodeVisitor:
     def _array(self, array: "scout_compute_resolved_api_ArraySeriesNode") -> Any:
         pass
 
+    @abstractmethod
+    def _struct(self, struct: "scout_compute_resolved_api_StructSeriesNode") -> Any:
+        pass
+
 
 scout_compute_resolved_api_SeriesNodeVisitor.__name__ = "SeriesNodeVisitor"
 scout_compute_resolved_api_SeriesNodeVisitor.__qualname__ = "SeriesNodeVisitor"
@@ -65656,6 +65900,62 @@ scout_compute_resolved_api_StorageLocatorVisitor.__qualname__ = "StorageLocatorV
 scout_compute_resolved_api_StorageLocatorVisitor.__module__ = "nominal_api.scout_compute_resolved_api"
 
 
+class scout_compute_resolved_api_StructSeriesNode(ConjureUnionType):
+    _raw: Optional["scout_compute_resolved_api_ResolvedSeries"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'raw': ConjureFieldDefinition('raw', scout_compute_resolved_api_ResolvedSeries)
+        }
+
+    def __init__(
+            self,
+            raw: Optional["scout_compute_resolved_api_ResolvedSeries"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (raw is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if raw is not None:
+                self._raw = raw
+                self._type = 'raw'
+
+        elif type_of_union == 'raw':
+            if raw is None:
+                raise ValueError('a union value must not be None')
+            self._raw = raw
+            self._type = 'raw'
+
+    @builtins.property
+    def raw(self) -> Optional["scout_compute_resolved_api_ResolvedSeries"]:
+        return self._raw
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_compute_resolved_api_StructSeriesNodeVisitor):
+            raise ValueError('{} is not an instance of scout_compute_resolved_api_StructSeriesNodeVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'raw' and self.raw is not None:
+            return visitor._raw(self.raw)
+
+
+scout_compute_resolved_api_StructSeriesNode.__name__ = "StructSeriesNode"
+scout_compute_resolved_api_StructSeriesNode.__qualname__ = "StructSeriesNode"
+scout_compute_resolved_api_StructSeriesNode.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
+class scout_compute_resolved_api_StructSeriesNodeVisitor:
+
+    @abstractmethod
+    def _raw(self, raw: "scout_compute_resolved_api_ResolvedSeries") -> Any:
+        pass
+
+
+scout_compute_resolved_api_StructSeriesNodeVisitor.__name__ = "StructSeriesNodeVisitor"
+scout_compute_resolved_api_StructSeriesNodeVisitor.__qualname__ = "StructSeriesNodeVisitor"
+scout_compute_resolved_api_StructSeriesNodeVisitor.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
 class scout_compute_resolved_api_SumSeriesNode(ConjureBeanType):
 
     @builtins.classmethod
@@ -92406,6 +92706,8 @@ class storage_series_api_NominalDataType(ConjureEnumType):
     '''DOUBLE_ARRAY'''
     STRING_ARRAY = 'STRING_ARRAY'
     '''STRING_ARRAY'''
+    STRUCT = 'STRUCT'
+    '''STRUCT'''
     UNKNOWN = 'UNKNOWN'
     '''UNKNOWN'''
 
@@ -93268,6 +93570,7 @@ Logs specifically are supported externally via a separate endpoint.
     _log: Optional[List["storage_writer_api_LogPoint"]] = None
     _int_: Optional[List["storage_writer_api_IntPoint"]] = None
     _array: Optional["storage_writer_api_ArrayPoints"] = None
+    _struct: Optional[List["storage_writer_api_StructPoint"]] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
@@ -93276,7 +93579,8 @@ Logs specifically are supported externally via a separate endpoint.
             'double': ConjureFieldDefinition('double', List[storage_writer_api_DoublePoint]),
             'log': ConjureFieldDefinition('log', List[storage_writer_api_LogPoint]),
             'int_': ConjureFieldDefinition('int', List[storage_writer_api_IntPoint]),
-            'array': ConjureFieldDefinition('array', storage_writer_api_ArrayPoints)
+            'array': ConjureFieldDefinition('array', storage_writer_api_ArrayPoints),
+            'struct': ConjureFieldDefinition('struct', List[storage_writer_api_StructPoint])
         }
 
     def __init__(
@@ -93286,10 +93590,11 @@ Logs specifically are supported externally via a separate endpoint.
             log: Optional[List["storage_writer_api_LogPoint"]] = None,
             int_: Optional[List["storage_writer_api_IntPoint"]] = None,
             array: Optional["storage_writer_api_ArrayPoints"] = None,
+            struct: Optional[List["storage_writer_api_StructPoint"]] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (string is not None) + (double is not None) + (log is not None) + (int_ is not None) + (array is not None) != 1:
+            if (string is not None) + (double is not None) + (log is not None) + (int_ is not None) + (array is not None) + (struct is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if string is not None:
@@ -93307,6 +93612,9 @@ Logs specifically are supported externally via a separate endpoint.
             if array is not None:
                 self._array = array
                 self._type = 'array'
+            if struct is not None:
+                self._struct = struct
+                self._type = 'struct'
 
         elif type_of_union == 'string':
             if string is None:
@@ -93333,6 +93641,11 @@ Logs specifically are supported externally via a separate endpoint.
                 raise ValueError('a union value must not be None')
             self._array = array
             self._type = 'array'
+        elif type_of_union == 'struct':
+            if struct is None:
+                raise ValueError('a union value must not be None')
+            self._struct = struct
+            self._type = 'struct'
 
     @builtins.property
     def string(self) -> Optional[List["storage_writer_api_StringPoint"]]:
@@ -93354,6 +93667,10 @@ Logs specifically are supported externally via a separate endpoint.
     def array(self) -> Optional["storage_writer_api_ArrayPoints"]:
         return self._array
 
+    @builtins.property
+    def struct(self) -> Optional[List["storage_writer_api_StructPoint"]]:
+        return self._struct
+
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, storage_writer_api_PointsVisitor):
             raise ValueError('{} is not an instance of storage_writer_api_PointsVisitor'.format(visitor.__class__.__name__))
@@ -93367,6 +93684,8 @@ Logs specifically are supported externally via a separate endpoint.
             return visitor._int(self.int_)
         if self._type == 'array' and self.array is not None:
             return visitor._array(self.array)
+        if self._type == 'struct' and self.struct is not None:
+            return visitor._struct(self.struct)
 
 
 storage_writer_api_Points.__name__ = "Points"
@@ -93396,6 +93715,10 @@ class storage_writer_api_PointsVisitor:
     def _array(self, array: "storage_writer_api_ArrayPoints") -> Any:
         pass
 
+    @abstractmethod
+    def _struct(self, struct: List["storage_writer_api_StructPoint"]) -> Any:
+        pass
+
 
 storage_writer_api_PointsVisitor.__name__ = "PointsVisitor"
 storage_writer_api_PointsVisitor.__qualname__ = "PointsVisitor"
@@ -93628,6 +93951,35 @@ storage_writer_api_StringPoint.__qualname__ = "StringPoint"
 storage_writer_api_StringPoint.__module__ = "nominal_api.storage_writer_api"
 
 
+class storage_writer_api_StructPoint(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'timestamp': ConjureFieldDefinition('timestamp', api_Timestamp),
+            'value': ConjureFieldDefinition('value', str)
+        }
+
+    __slots__: List[str] = ['_timestamp', '_value']
+
+    def __init__(self, timestamp: "api_Timestamp", value: str) -> None:
+        self._timestamp = timestamp
+        self._value = value
+
+    @builtins.property
+    def timestamp(self) -> "api_Timestamp":
+        return self._timestamp
+
+    @builtins.property
+    def value(self) -> str:
+        return self._value
+
+
+storage_writer_api_StructPoint.__name__ = "StructPoint"
+storage_writer_api_StructPoint.__qualname__ = "StructPoint"
+storage_writer_api_StructPoint.__module__ = "nominal_api.storage_writer_api"
+
+
 class storage_writer_api_TelegrafMetric(ConjureBeanType):
 
     @builtins.classmethod
@@ -93812,6 +94164,38 @@ storage_writer_api_WriteLogsRequest.__qualname__ = "WriteLogsRequest"
 storage_writer_api_WriteLogsRequest.__module__ = "nominal_api.storage_writer_api"
 
 
+class storage_writer_api_WriteStructsRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'structs': ConjureFieldDefinition('structs', List[storage_writer_api_StructPoint]),
+            'channel': ConjureFieldDefinition('channel', OptionalTypeWrapper[api_Channel])
+        }
+
+    __slots__: List[str] = ['_structs', '_channel']
+
+    def __init__(self, structs: List["storage_writer_api_StructPoint"], channel: Optional[str] = None) -> None:
+        self._structs = structs
+        self._channel = channel
+
+    @builtins.property
+    def structs(self) -> List["storage_writer_api_StructPoint"]:
+        return self._structs
+
+    @builtins.property
+    def channel(self) -> Optional[str]:
+        """If provided, the channel to which to write structs.
+If not provided, defaults to "structs"
+        """
+        return self._channel
+
+
+storage_writer_api_WriteStructsRequest.__name__ = "WriteStructsRequest"
+storage_writer_api_WriteStructsRequest.__qualname__ = "WriteStructsRequest"
+storage_writer_api_WriteStructsRequest.__module__ = "nominal_api.storage_writer_api"
+
+
 class storage_writer_api_WriteTelegrafBatchesRequest(ConjureBeanType):
 
     @builtins.classmethod

{nominal_api-0.977.0 → nominal_api-0.978.0}/nominal_api/event/__init__.py

@@ -9,6 +9,8 @@ from .._impl import (
     event_ArchiveEvent as ArchiveEvent,
     event_AssetsFilter as AssetsFilter,
     event_AssigneesFilter as AssigneesFilter,
+    event_BatchAggregateEventsRequest as BatchAggregateEventsRequest,
+    event_BatchAggregateEventsResponse as BatchAggregateEventsResponse,
     event_BatchUpdateDispositionRequest as BatchUpdateDispositionRequest,
     event_BatchUpdateDispositionResponse as BatchUpdateDispositionResponse,
     event_BatchUpdateEventRequest as BatchUpdateEventRequest,
@@ -63,6 +65,8 @@ __all__ = [
     'ArchiveEvent',
     'AssetsFilter',
     'AssigneesFilter',
+    'BatchAggregateEventsRequest',
+    'BatchAggregateEventsResponse',
     'BatchUpdateDispositionRequest',
     'BatchUpdateDispositionResponse',
     'BatchUpdateEventRequest',

{nominal_api-0.977.0 → nominal_api-0.978.0}/nominal_api/scout_compute_api/__init__.py

@@ -329,6 +329,8 @@ from .._impl import (
     scout_compute_api_StringConstantVisitor as StringConstantVisitor,
     scout_compute_api_StringSetConstant as StringSetConstant,
     scout_compute_api_StringSetConstantVisitor as StringSetConstantVisitor,
+    scout_compute_api_StructSeries as StructSeries,
+    scout_compute_api_StructSeriesVisitor as StructSeriesVisitor,
     scout_compute_api_Sum as Sum,
     scout_compute_api_SumSeries as SumSeries,
     scout_compute_api_SummarizationStrategy as SummarizationStrategy,
@@ -710,6 +712,8 @@ __all__ = [
     'StringConstantVisitor',
     'StringSetConstant',
     'StringSetConstantVisitor',
+    'StructSeries',
+    'StructSeriesVisitor',
     'Sum',
     'SumSeries',
     'SummarizationStrategy',

{nominal_api-0.977.0 → nominal_api-0.978.0}/nominal_api/scout_compute_resolved_api/__init__.py

@@ -142,6 +142,8 @@ from .._impl import (
     scout_compute_resolved_api_StaleRangesNode as StaleRangesNode,
     scout_compute_resolved_api_StorageLocator as StorageLocator,
     scout_compute_resolved_api_StorageLocatorVisitor as StorageLocatorVisitor,
+    scout_compute_resolved_api_StructSeriesNode as StructSeriesNode,
+    scout_compute_resolved_api_StructSeriesNodeVisitor as StructSeriesNodeVisitor,
     scout_compute_resolved_api_SumSeriesNode as SumSeriesNode,
     scout_compute_resolved_api_SummarizeCartesian3dNode as SummarizeCartesian3dNode,
     scout_compute_resolved_api_SummarizeCartesianNode as SummarizeCartesianNode,
@@ -309,6 +311,8 @@ __all__ = [
     'StaleRangesNode',
     'StorageLocator',
     'StorageLocatorVisitor',
+    'StructSeriesNode',
+    'StructSeriesNodeVisitor',
     'SumSeriesNode',
     'SummarizeCartesian3dNode',
     'SummarizeCartesianNode',

{nominal_api-0.977.0 → nominal_api-0.978.0}/nominal_api/storage_writer_api/__init__.py

@@ -24,11 +24,13 @@ from .._impl import (
     storage_writer_api_RecordsBatchExternal as RecordsBatchExternal,
     storage_writer_api_StringArrayPoint as StringArrayPoint,
     storage_writer_api_StringPoint as StringPoint,
+    storage_writer_api_StructPoint as StructPoint,
     storage_writer_api_TelegrafMetric as TelegrafMetric,
     storage_writer_api_WriteBatchesRequest as WriteBatchesRequest,
     storage_writer_api_WriteBatchesRequestExternal as WriteBatchesRequestExternal,
     storage_writer_api_WriteColumnBatchesRequest as WriteColumnBatchesRequest,
     storage_writer_api_WriteLogsRequest as WriteLogsRequest,
+    storage_writer_api_WriteStructsRequest as WriteStructsRequest,
     storage_writer_api_WriteTelegrafBatchesRequest as WriteTelegrafBatchesRequest,
 )
 
@@ -55,11 +57,13 @@ __all__ = [
     'RecordsBatchExternal',
     'StringArrayPoint',
     'StringPoint',
+    'StructPoint',
     'TelegrafMetric',
     'WriteBatchesRequest',
     'WriteBatchesRequestExternal',
     'WriteColumnBatchesRequest',
     'WriteLogsRequest',
+    'WriteStructsRequest',
     'WriteTelegrafBatchesRequest',
     'DirectNominalChannelWriterService',
     'NominalChannelWriterService',

{nominal_api-0.977.0 → nominal_api-0.978.0}/nominal_api.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nominal-api
-Version: 0.977.0
+Version: 0.978.0
 Requires-Python: >=3.8
 Requires-Dist: requests
 Requires-Dist: conjure-python-client<4,>=2.8.0

{nominal_api-0.977.0 → nominal_api-0.978.0}/setup.py

@@ -6,7 +6,7 @@ from setuptools import (
 
 setup(
     name='nominal-api',
-    version='0.977.0',
+    version='0.978.0',
     python_requires='>=3.8',
     package_data={"": ["py.typed"]},
     packages=find_packages(),