nominal-api 0.620.0__py3-none-any.whl → 0.622.0__py3-none-any.whl

nominal_api/_impl.py

@@ -2433,6 +2433,83 @@ authorization_AuthorizationService.__qualname__ = "AuthorizationService"
 authorization_AuthorizationService.__module__ = "nominal_api.authorization"
 
 
+class authorization_Claim(ConjureUnionType):
+    _string: Optional[str] = None
+    _string_list: Optional[List[str]] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'string': ConjureFieldDefinition('string', str),
+            'string_list': ConjureFieldDefinition('stringList', List[str])
+        }
+
+    def __init__(
+            self,
+            string: Optional[str] = None,
+            string_list: Optional[List[str]] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (string is not None) + (string_list is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if string is not None:
+                self._string = string
+                self._type = 'string'
+            if string_list is not None:
+                self._string_list = string_list
+                self._type = 'stringList'
+
+        elif type_of_union == 'string':
+            if string is None:
+                raise ValueError('a union value must not be None')
+            self._string = string
+            self._type = 'string'
+        elif type_of_union == 'stringList':
+            if string_list is None:
+                raise ValueError('a union value must not be None')
+            self._string_list = string_list
+            self._type = 'stringList'
+
+    @builtins.property
+    def string(self) -> Optional[str]:
+        return self._string
+
+    @builtins.property
+    def string_list(self) -> Optional[List[str]]:
+        return self._string_list
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, authorization_ClaimVisitor):
+            raise ValueError('{} is not an instance of authorization_ClaimVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'string' and self.string is not None:
+            return visitor._string(self.string)
+        if self._type == 'stringList' and self.string_list is not None:
+            return visitor._string_list(self.string_list)
+
+
+authorization_Claim.__name__ = "Claim"
+authorization_Claim.__qualname__ = "Claim"
+authorization_Claim.__module__ = "nominal_api.authorization"
+
+
+class authorization_ClaimVisitor:
+
+    @abstractmethod
+    def _string(self, string: str) -> Any:
+        pass
+
+    @abstractmethod
+    def _string_list(self, string_list: List[str]) -> Any:
+        pass
+
+
+authorization_ClaimVisitor.__name__ = "ClaimVisitor"
+authorization_ClaimVisitor.__qualname__ = "ClaimVisitor"
+authorization_ClaimVisitor.__module__ = "nominal_api.authorization"
+
+
 class authorization_CreateApiKeyRequest(ConjureBeanType):
 
     @builtins.classmethod
@@ -6952,8 +7029,8 @@ class ingest_api_ContainerizedOpts(ConjureBeanType):
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'sources': ConjureFieldDefinition('sources', Dict[ingest_api_ExtractorInputName, ingest_api_IngestSource]),
-            'extractor': ConjureFieldDefinition('extractor', str),
+            'sources': ConjureFieldDefinition('sources', Dict[ingest_api_EnvironmentVariable, ingest_api_IngestSource]),
+            'extractor': ConjureFieldDefinition('extractor', ingest_api_ContainerizedExtractorRid),
             'timestamp_metadata': ConjureFieldDefinition('timestampMetadata', OptionalTypeWrapper[ingest_api_TimestampMetadata]),
             'target': ConjureFieldDefinition('target', ingest_api_DatasetIngestTarget)
         }
@@ -7001,17 +7078,19 @@ class ingest_api_CsvOpts(ConjureBeanType):
             'timestamp_metadata': ConjureFieldDefinition('timestampMetadata', ingest_api_TimestampMetadata),
             'channel_prefix': ConjureFieldDefinition('channelPrefix', ingest_api_ChannelPrefix),
             'tag_keys_from_columns': ConjureFieldDefinition('tagKeysFromColumns', OptionalTypeWrapper[List[api_TagName]]),
+            'tag_columns': ConjureFieldDefinition('tagColumns', OptionalTypeWrapper[Dict[api_TagName, api_ColumnName]]),
             'additional_file_tags': ConjureFieldDefinition('additionalFileTags', OptionalTypeWrapper[Dict[api_TagName, api_TagValue]])
         }
 
-    __slots__: List[str] = ['_source', '_target', '_timestamp_metadata', '_channel_prefix', '_tag_keys_from_columns', '_additional_file_tags']
+    __slots__: List[str] = ['_source', '_target', '_timestamp_metadata', '_channel_prefix', '_tag_keys_from_columns', '_tag_columns', '_additional_file_tags']
 
-    def __init__(self, source: "ingest_api_IngestSource", target: "ingest_api_DatasetIngestTarget", timestamp_metadata: "ingest_api_TimestampMetadata", additional_file_tags: Optional[Dict[str, str]] = None, channel_prefix: Optional[str] = None, tag_keys_from_columns: Optional[List[str]] = None) -> None:
+    def __init__(self, source: "ingest_api_IngestSource", target: "ingest_api_DatasetIngestTarget", timestamp_metadata: "ingest_api_TimestampMetadata", additional_file_tags: Optional[Dict[str, str]] = None, channel_prefix: Optional[str] = None, tag_columns: Optional[Dict[str, str]] = None, tag_keys_from_columns: Optional[List[str]] = None) -> None:
         self._source = source
         self._target = target
         self._timestamp_metadata = timestamp_metadata
         self._channel_prefix = channel_prefix
         self._tag_keys_from_columns = tag_keys_from_columns
+        self._tag_columns = tag_columns
         self._additional_file_tags = additional_file_tags
 
     @builtins.property
@@ -7034,6 +7113,13 @@ class ingest_api_CsvOpts(ConjureBeanType):
     def tag_keys_from_columns(self) -> Optional[List[str]]:
         return self._tag_keys_from_columns
 
+    @builtins.property
+    def tag_columns(self) -> Optional[Dict[str, str]]:
+        """
+        A map of tag names to column names to derive the tag values from.
+        """
+        return self._tag_columns
+
     @builtins.property
     def additional_file_tags(self) -> Optional[Dict[str, str]]:
         return self._additional_file_tags
@@ -9866,18 +9952,20 @@ and archives such as .tar, .tar.gz, and .zip (must set the isArchive flag).
             'timestamp_metadata': ConjureFieldDefinition('timestampMetadata', ingest_api_TimestampMetadata),
             'channel_prefix': ConjureFieldDefinition('channelPrefix', ingest_api_ChannelPrefix),
             'tag_keys_from_columns': ConjureFieldDefinition('tagKeysFromColumns', OptionalTypeWrapper[List[api_TagName]]),
+            'tag_columns': ConjureFieldDefinition('tagColumns', OptionalTypeWrapper[Dict[api_TagName, api_ColumnName]]),
             'additional_file_tags': ConjureFieldDefinition('additionalFileTags', OptionalTypeWrapper[Dict[api_TagName, api_TagValue]]),
             'is_archive': ConjureFieldDefinition('isArchive', OptionalTypeWrapper[bool])
         }
 
-    __slots__: List[str] = ['_source', '_target', '_timestamp_metadata', '_channel_prefix', '_tag_keys_from_columns', '_additional_file_tags', '_is_archive']
+    __slots__: List[str] = ['_source', '_target', '_timestamp_metadata', '_channel_prefix', '_tag_keys_from_columns', '_tag_columns', '_additional_file_tags', '_is_archive']
 
-    def __init__(self, source: "ingest_api_IngestSource", target: "ingest_api_DatasetIngestTarget", timestamp_metadata: "ingest_api_TimestampMetadata", additional_file_tags: Optional[Dict[str, str]] = None, channel_prefix: Optional[str] = None, is_archive: Optional[bool] = None, tag_keys_from_columns: Optional[List[str]] = None) -> None:
+    def __init__(self, source: "ingest_api_IngestSource", target: "ingest_api_DatasetIngestTarget", timestamp_metadata: "ingest_api_TimestampMetadata", additional_file_tags: Optional[Dict[str, str]] = None, channel_prefix: Optional[str] = None, is_archive: Optional[bool] = None, tag_columns: Optional[Dict[str, str]] = None, tag_keys_from_columns: Optional[List[str]] = None) -> None:
         self._source = source
         self._target = target
         self._timestamp_metadata = timestamp_metadata
         self._channel_prefix = channel_prefix
         self._tag_keys_from_columns = tag_keys_from_columns
+        self._tag_columns = tag_columns
         self._additional_file_tags = additional_file_tags
         self._is_archive = is_archive
 
@@ -9901,6 +9989,13 @@ and archives such as .tar, .tar.gz, and .zip (must set the isArchive flag).
     def tag_keys_from_columns(self) -> Optional[List[str]]:
         return self._tag_keys_from_columns
 
+    @builtins.property
+    def tag_columns(self) -> Optional[Dict[str, str]]:
+        """
+        A map of tag names to column names to derive the tag values from.
+        """
+        return self._tag_columns
+
     @builtins.property
     def additional_file_tags(self) -> Optional[Dict[str, str]]:
         return self._additional_file_tags
@@ -11158,6 +11253,547 @@ ingest_api_VideoTimestampManifestVisitor.__qualname__ = "VideoTimestampManifestV
 ingest_api_VideoTimestampManifestVisitor.__module__ = "nominal_api.ingest_api"
 
 
+class ingest_workflow_api_Empty(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+        }
+
+    __slots__: List[str] = []
+
+
+
+ingest_workflow_api_Empty.__name__ = "Empty"
+ingest_workflow_api_Empty.__qualname__ = "Empty"
+ingest_workflow_api_Empty.__module__ = "nominal_api.ingest_workflow_api"
+
+
+class ingest_workflow_api_EnsureExtractorJobCreatedRequest(ConjureBeanType):
+    """
+    Ensure that the extractor job exists in the control plane. Runs in the namespace given by workspaceRid.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'workspace_rid': ConjureFieldDefinition('workspaceRid', api_rids_WorkspaceRid),
+            'ingest_job_uuid': ConjureFieldDefinition('ingestJobUuid', str),
+            'containerized_extractor': ConjureFieldDefinition('containerizedExtractor', ingest_api_ContainerizedExtractor),
+            'source_handles': ConjureFieldDefinition('sourceHandles', Dict[str, scout_catalog_S3Handle])
+        }
+
+    __slots__: List[str] = ['_workspace_rid', '_ingest_job_uuid', '_containerized_extractor', '_source_handles']
+
+    def __init__(self, containerized_extractor: "ingest_api_ContainerizedExtractor", ingest_job_uuid: str, source_handles: Dict[str, "scout_catalog_S3Handle"], workspace_rid: str) -> None:
+        self._workspace_rid = workspace_rid
+        self._ingest_job_uuid = ingest_job_uuid
+        self._containerized_extractor = containerized_extractor
+        self._source_handles = source_handles
+
+    @builtins.property
+    def workspace_rid(self) -> str:
+        return self._workspace_rid
+
+    @builtins.property
+    def ingest_job_uuid(self) -> str:
+        return self._ingest_job_uuid
+
+    @builtins.property
+    def containerized_extractor(self) -> "ingest_api_ContainerizedExtractor":
+        return self._containerized_extractor
+
+    @builtins.property
+    def source_handles(self) -> Dict[str, "scout_catalog_S3Handle"]:
+        return self._source_handles
+
+
+ingest_workflow_api_EnsureExtractorJobCreatedRequest.__name__ = "EnsureExtractorJobCreatedRequest"
+ingest_workflow_api_EnsureExtractorJobCreatedRequest.__qualname__ = "EnsureExtractorJobCreatedRequest"
+ingest_workflow_api_EnsureExtractorJobCreatedRequest.__module__ = "nominal_api.ingest_workflow_api"
+
+
+class ingest_workflow_api_EnsureExtractorJobCreatedResponse(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+        }
+
+    __slots__: List[str] = []
+
+
+
+ingest_workflow_api_EnsureExtractorJobCreatedResponse.__name__ = "EnsureExtractorJobCreatedResponse"
+ingest_workflow_api_EnsureExtractorJobCreatedResponse.__qualname__ = "EnsureExtractorJobCreatedResponse"
+ingest_workflow_api_EnsureExtractorJobCreatedResponse.__module__ = "nominal_api.ingest_workflow_api"
+
+
+class ingest_workflow_api_EnsureWorkspaceNamespaceCreatedRequest(ConjureBeanType):
+    """
+    For a given workspace rid, ensures that there is a corresponding K8s namespace created.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'workspace_rid': ConjureFieldDefinition('workspaceRid', api_rids_WorkspaceRid)
+        }
+
+    __slots__: List[str] = ['_workspace_rid']
+
+    def __init__(self, workspace_rid: str) -> None:
+        self._workspace_rid = workspace_rid
+
+    @builtins.property
+    def workspace_rid(self) -> str:
+        return self._workspace_rid
+
+
+ingest_workflow_api_EnsureWorkspaceNamespaceCreatedRequest.__name__ = "EnsureWorkspaceNamespaceCreatedRequest"
+ingest_workflow_api_EnsureWorkspaceNamespaceCreatedRequest.__qualname__ = "EnsureWorkspaceNamespaceCreatedRequest"
+ingest_workflow_api_EnsureWorkspaceNamespaceCreatedRequest.__module__ = "nominal_api.ingest_workflow_api"
+
+
+class ingest_workflow_api_EnsureWorkspaceServiceAccountCreatedRequest(ConjureBeanType):
+    """
+    For a given workspace rid, ensures that there is a service account in the proper K8s Namespace.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'workspace_rid': ConjureFieldDefinition('workspaceRid', api_rids_WorkspaceRid)
+        }
+
+    __slots__: List[str] = ['_workspace_rid']
+
+    def __init__(self, workspace_rid: str) -> None:
+        self._workspace_rid = workspace_rid
+
+    @builtins.property
+    def workspace_rid(self) -> str:
+        return self._workspace_rid
+
+
+ingest_workflow_api_EnsureWorkspaceServiceAccountCreatedRequest.__name__ = "EnsureWorkspaceServiceAccountCreatedRequest"
+ingest_workflow_api_EnsureWorkspaceServiceAccountCreatedRequest.__qualname__ = "EnsureWorkspaceServiceAccountCreatedRequest"
+ingest_workflow_api_EnsureWorkspaceServiceAccountCreatedRequest.__module__ = "nominal_api.ingest_workflow_api"
+
+
+class ingest_workflow_api_ExtractorJobState(ConjureEnumType):
+
+    PENDING = 'PENDING'
+    '''PENDING'''
+    RUNNING = 'RUNNING'
+    '''RUNNING'''
+    FAILED = 'FAILED'
+    '''FAILED'''
+    SUCCEEDED = 'SUCCEEDED'
+    '''SUCCEEDED'''
+    UNKNOWN = 'UNKNOWN'
+    '''UNKNOWN'''
+
+    def __reduce_ex__(self, proto):
+        return self.__class__, (self.name,)
+
+
+ingest_workflow_api_ExtractorJobState.__name__ = "ExtractorJobState"
+ingest_workflow_api_ExtractorJobState.__qualname__ = "ExtractorJobState"
+ingest_workflow_api_ExtractorJobState.__module__ = "nominal_api.ingest_workflow_api"
+
+
+class ingest_workflow_api_GetExtractorJobStateRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'workspace_rid': ConjureFieldDefinition('workspaceRid', api_rids_WorkspaceRid),
+            'ingest_job_uuid': ConjureFieldDefinition('ingestJobUuid', str)
+        }
+
+    __slots__: List[str] = ['_workspace_rid', '_ingest_job_uuid']
+
+    def __init__(self, ingest_job_uuid: str, workspace_rid: str) -> None:
+        self._workspace_rid = workspace_rid
+        self._ingest_job_uuid = ingest_job_uuid
+
+    @builtins.property
+    def workspace_rid(self) -> str:
+        return self._workspace_rid
+
+    @builtins.property
+    def ingest_job_uuid(self) -> str:
+        return self._ingest_job_uuid
+
+
+ingest_workflow_api_GetExtractorJobStateRequest.__name__ = "GetExtractorJobStateRequest"
+ingest_workflow_api_GetExtractorJobStateRequest.__qualname__ = "GetExtractorJobStateRequest"
+ingest_workflow_api_GetExtractorJobStateRequest.__module__ = "nominal_api.ingest_workflow_api"
+
+
+class ingest_workflow_api_GetExtractorJobStateResponse(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'state': ConjureFieldDefinition('state', ingest_workflow_api_ExtractorJobState)
+        }
+
+    __slots__: List[str] = ['_state']
+
+    def __init__(self, state: "ingest_workflow_api_ExtractorJobState") -> None:
+        self._state = state
+
+    @builtins.property
+    def state(self) -> "ingest_workflow_api_ExtractorJobState":
+        return self._state
+
+
+ingest_workflow_api_GetExtractorJobStateResponse.__name__ = "GetExtractorJobStateResponse"
+ingest_workflow_api_GetExtractorJobStateResponse.__qualname__ = "GetExtractorJobStateResponse"
+ingest_workflow_api_GetExtractorJobStateResponse.__module__ = "nominal_api.ingest_workflow_api"
+
+
+class ingest_workflow_api_IngestDataflashRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'locator': ConjureFieldDefinition('locator', ingest_workflow_api_ObjectLocator)
+        }
+
+    __slots__: List[str] = ['_locator']
+
+    def __init__(self, locator: "ingest_workflow_api_ObjectLocator") -> None:
+        self._locator = locator
+
+    @builtins.property
+    def locator(self) -> "ingest_workflow_api_ObjectLocator":
+        return self._locator
+
+
+ingest_workflow_api_IngestDataflashRequest.__name__ = "IngestDataflashRequest"
+ingest_workflow_api_IngestDataflashRequest.__qualname__ = "IngestDataflashRequest"
+ingest_workflow_api_IngestDataflashRequest.__module__ = "nominal_api.ingest_workflow_api"
+
+
+class ingest_workflow_api_IngestDataflashResponse(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'units': ConjureFieldDefinition('units', Dict[str, str]),
+            'parquet_object_locators': ConjureFieldDefinition('parquetObjectLocators', List[ingest_workflow_api_ObjectLocator]),
+            'timestamp_series_name': ConjureFieldDefinition('timestampSeriesName', str),
+            'time_unit': ConjureFieldDefinition('timeUnit', ingest_workflow_api_TimeUnitSeconds)
+        }
+
+    __slots__: List[str] = ['_units', '_parquet_object_locators', '_timestamp_series_name', '_time_unit']
+
+    def __init__(self, parquet_object_locators: List["ingest_workflow_api_ObjectLocator"], time_unit: "ingest_workflow_api_TimeUnitSeconds", timestamp_series_name: str, units: Dict[str, str]) -> None:
+        self._units = units
+        self._parquet_object_locators = parquet_object_locators
+        self._timestamp_series_name = timestamp_series_name
+        self._time_unit = time_unit
+
+    @builtins.property
+    def units(self) -> Dict[str, str]:
+        return self._units
+
+    @builtins.property
+    def parquet_object_locators(self) -> List["ingest_workflow_api_ObjectLocator"]:
+        """
+        Azure or S3-style blob locators of parquet files. Currently
+only a single file is supported, the list type is used for future compatibility.
+        """
+        return self._parquet_object_locators
+
+    @builtins.property
+    def timestamp_series_name(self) -> str:
+        """
+        The name of the column in the generated parquet file that contains the timestamp.
+        """
+        return self._timestamp_series_name
+
+    @builtins.property
+    def time_unit(self) -> "ingest_workflow_api_TimeUnitSeconds":
+        """
+        The unit of time for the timestamp column. Can only be seconds.
+        """
+        return self._time_unit
+
+
+ingest_workflow_api_IngestDataflashResponse.__name__ = "IngestDataflashResponse"
+ingest_workflow_api_IngestDataflashResponse.__qualname__ = "IngestDataflashResponse"
+ingest_workflow_api_IngestDataflashResponse.__module__ = "nominal_api.ingest_workflow_api"
+
+
+class ingest_workflow_api_IngestMcapProtobufRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'locator': ConjureFieldDefinition('locator', ingest_workflow_api_ObjectLocator),
+            'channels': ConjureFieldDefinition('channels', ingest_workflow_api_McapProtoChannels)
+        }
+
+    __slots__: List[str] = ['_locator', '_channels']
+
+    def __init__(self, channels: "ingest_workflow_api_McapProtoChannels", locator: "ingest_workflow_api_ObjectLocator") -> None:
+        self._locator = locator
+        self._channels = channels
+
+    @builtins.property
+    def locator(self) -> "ingest_workflow_api_ObjectLocator":
+        return self._locator
+
+    @builtins.property
+    def channels(self) -> "ingest_workflow_api_McapProtoChannels":
+        return self._channels
+
+
+ingest_workflow_api_IngestMcapProtobufRequest.__name__ = "IngestMcapProtobufRequest"
+ingest_workflow_api_IngestMcapProtobufRequest.__qualname__ = "IngestMcapProtobufRequest"
+ingest_workflow_api_IngestMcapProtobufRequest.__module__ = "nominal_api.ingest_workflow_api"
+
+
+class ingest_workflow_api_IngestMcapProtobufResponse(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'timestamp_column_name': ConjureFieldDefinition('timestampColumnName', str),
+            'parquet_object_locators': ConjureFieldDefinition('parquetObjectLocators', List[ingest_workflow_api_ObjectLocator])
+        }
+
+    __slots__: List[str] = ['_timestamp_column_name', '_parquet_object_locators']
+
+    def __init__(self, parquet_object_locators: List["ingest_workflow_api_ObjectLocator"], timestamp_column_name: str) -> None:
+        self._timestamp_column_name = timestamp_column_name
+        self._parquet_object_locators = parquet_object_locators
+
+    @builtins.property
+    def timestamp_column_name(self) -> str:
+        return self._timestamp_column_name
+
+    @builtins.property
+    def parquet_object_locators(self) -> List["ingest_workflow_api_ObjectLocator"]:
+        """
+        Azure or S3-style blob locators of parquet files. Currently
+only a single file is supported, the list type is used for future compatibility.
+        """
+        return self._parquet_object_locators
+
+
+ingest_workflow_api_IngestMcapProtobufResponse.__name__ = "IngestMcapProtobufResponse"
+ingest_workflow_api_IngestMcapProtobufResponse.__qualname__ = "IngestMcapProtobufResponse"
+ingest_workflow_api_IngestMcapProtobufResponse.__module__ = "nominal_api.ingest_workflow_api"
+
+
+class ingest_workflow_api_McapProtoChannels(ConjureUnionType):
+    _all: Optional["ingest_workflow_api_Empty"] = None
+    _include_topics: Optional[List[str]] = None
+    _exclude_topics: Optional[List[str]] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'all': ConjureFieldDefinition('all', ingest_workflow_api_Empty),
+            'include_topics': ConjureFieldDefinition('includeTopics', List[ingest_workflow_api_McapTopicName]),
+            'exclude_topics': ConjureFieldDefinition('excludeTopics', List[ingest_workflow_api_McapTopicName])
+        }
+
+    def __init__(
+            self,
+            all: Optional["ingest_workflow_api_Empty"] = None,
+            include_topics: Optional[List[str]] = None,
+            exclude_topics: Optional[List[str]] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (all is not None) + (include_topics is not None) + (exclude_topics is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if all is not None:
+                self._all = all
+                self._type = 'all'
+            if include_topics is not None:
+                self._include_topics = include_topics
+                self._type = 'includeTopics'
+            if exclude_topics is not None:
+                self._exclude_topics = exclude_topics
+                self._type = 'excludeTopics'
+
+        elif type_of_union == 'all':
+            if all is None:
+                raise ValueError('a union value must not be None')
+            self._all = all
+            self._type = 'all'
+        elif type_of_union == 'includeTopics':
+            if include_topics is None:
+                raise ValueError('a union value must not be None')
+            self._include_topics = include_topics
+            self._type = 'includeTopics'
+        elif type_of_union == 'excludeTopics':
+            if exclude_topics is None:
+                raise ValueError('a union value must not be None')
+            self._exclude_topics = exclude_topics
+            self._type = 'excludeTopics'
+
+    @builtins.property
+    def all(self) -> Optional["ingest_workflow_api_Empty"]:
+        return self._all
+
+    @builtins.property
+    def include_topics(self) -> Optional[List[str]]:
+        return self._include_topics
+
+    @builtins.property
+    def exclude_topics(self) -> Optional[List[str]]:
+        return self._exclude_topics
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, ingest_workflow_api_McapProtoChannelsVisitor):
+            raise ValueError('{} is not an instance of ingest_workflow_api_McapProtoChannelsVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'all' and self.all is not None:
+            return visitor._all(self.all)
+        if self._type == 'includeTopics' and self.include_topics is not None:
+            return visitor._include_topics(self.include_topics)
+        if self._type == 'excludeTopics' and self.exclude_topics is not None:
+            return visitor._exclude_topics(self.exclude_topics)
+
+
+ingest_workflow_api_McapProtoChannels.__name__ = "McapProtoChannels"
+ingest_workflow_api_McapProtoChannels.__qualname__ = "McapProtoChannels"
+ingest_workflow_api_McapProtoChannels.__module__ = "nominal_api.ingest_workflow_api"
+
+
+class ingest_workflow_api_McapProtoChannelsVisitor:
+
+    @abstractmethod
+    def _all(self, all: "ingest_workflow_api_Empty") -> Any:
+        pass
+
+    @abstractmethod
+    def _include_topics(self, include_topics: List[str]) -> Any:
+        pass
+
+    @abstractmethod
+    def _exclude_topics(self, exclude_topics: List[str]) -> Any:
+        pass
+
+
+ingest_workflow_api_McapProtoChannelsVisitor.__name__ = "McapProtoChannelsVisitor"
+ingest_workflow_api_McapProtoChannelsVisitor.__qualname__ = "McapProtoChannelsVisitor"
+ingest_workflow_api_McapProtoChannelsVisitor.__module__ = "nominal_api.ingest_workflow_api"
+
+
+class ingest_workflow_api_ObjectLocator(ConjureBeanType):
+    """
+    Locator for files in an object store. 
+Clients are expected to have auth and origin/region configured independently.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'bucket': ConjureFieldDefinition('bucket', str),
+            'object_name': ConjureFieldDefinition('objectName', str)
+        }
+
+    __slots__: List[str] = ['_bucket', '_object_name']
+
+    def __init__(self, bucket: str, object_name: str) -> None:
+        self._bucket = bucket
+        self._object_name = object_name
+
+    @builtins.property
+    def bucket(self) -> str:
+        return self._bucket
+
+    @builtins.property
+    def object_name(self) -> str:
+        return self._object_name
+
+
+ingest_workflow_api_ObjectLocator.__name__ = "ObjectLocator"
+ingest_workflow_api_ObjectLocator.__qualname__ = "ObjectLocator"
+ingest_workflow_api_ObjectLocator.__module__ = "nominal_api.ingest_workflow_api"
+
+
+class ingest_workflow_api_TimeUnitSeconds(ConjureEnumType):
+
+    SECONDS = 'SECONDS'
+    '''SECONDS'''
+    UNKNOWN = 'UNKNOWN'
+    '''UNKNOWN'''
+
+    def __reduce_ex__(self, proto):
+        return self.__class__, (self.name,)
+
+
+ingest_workflow_api_TimeUnitSeconds.__name__ = "TimeUnitSeconds"
+ingest_workflow_api_TimeUnitSeconds.__qualname__ = "TimeUnitSeconds"
+ingest_workflow_api_TimeUnitSeconds.__module__ = "nominal_api.ingest_workflow_api"
+
+
+class persistent_compute_api_AppendResult(ConjureBeanType):
+    """
+    An append result won't cover the full `StreamingComputeNodeRequest#windowWidth` but rather just a smaller 
+window. The end of the window that the append covers is guaranteed to be later than previously sent results.
+The start, however, can and most likely will overlap with previous results. That allows us to support 
+out-of-order points. The client will have to merge this new `AppendResult` with previous results.
+Example of time windows that might be covered by results for a subscription: 
+We send a full result for window [0s, 120s] followed by an append result for [116s, 121s] and another 
+append result for [117s, 122s].
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'subscription_id': ConjureFieldDefinition('subscriptionId', persistent_compute_api_SubscriptionId),
+            'start': ConjureFieldDefinition('start', api_Timestamp),
+            'end': ConjureFieldDefinition('end', api_Timestamp),
+            'result': ConjureFieldDefinition('result', persistent_compute_api_ComputeNodeAppendResponse)
+        }
+
+    __slots__: List[str] = ['_subscription_id', '_start', '_end', '_result']
+
+    def __init__(self, end: "api_Timestamp", result: "persistent_compute_api_ComputeNodeAppendResponse", start: "api_Timestamp", subscription_id: str) -> None:
+        self._subscription_id = subscription_id
+        self._start = start
+        self._end = end
+        self._result = result
+
+    @builtins.property
+    def subscription_id(self) -> str:
+        return self._subscription_id
+
+    @builtins.property
+    def start(self) -> "api_Timestamp":
+        """
+        The start of the time range that the append result covers
+        """
+        return self._start
+
+    @builtins.property
+    def end(self) -> "api_Timestamp":
+        """
+        The end of the time range that the append result covers
+        """
+        return self._end
+
+    @builtins.property
+    def result(self) -> "persistent_compute_api_ComputeNodeAppendResponse":
+        return self._result
+
+
+persistent_compute_api_AppendResult.__name__ = "AppendResult"
+persistent_compute_api_AppendResult.__qualname__ = "AppendResult"
+persistent_compute_api_AppendResult.__module__ = "nominal_api.persistent_compute_api"
+
+
 class persistent_compute_api_ClientMessage(ConjureUnionType):
     _subscribe: Optional[Dict[str, "persistent_compute_api_StreamingComputeNodeSubscription"]] = None
     _unsubscribe: Optional[List[str]] = None
@@ -11284,6 +11920,217 @@ persistent_compute_api_ClientMessageVisitor.__qualname__ = "ClientMessageVisitor
 persistent_compute_api_ClientMessageVisitor.__module__ = "nominal_api.persistent_compute_api"
 
 
+class persistent_compute_api_ComputeNodeAppendResponse(ConjureUnionType):
+    """These cover the subset of the union type in `ComputeWithUnitsResponse` for which we support append result.
+Append results will have the same subtype as the previous full result for the same `SubscriptionId`. 
+If the subtype were to change (e.g., we start doing bucketing because data frequency increased) we will send 
+a new full result with that new type. The results will also have the same units as the previous `FullResult`.
+Notably, we currently don't support appends for bucketed results as merging buckets is not trivial, especially 
+when accounting for out-of-order points."""
+    _range: Optional[List["scout_compute_api_Range"]] = None
+    _enum_point: Optional[Optional["scout_compute_api_EnumPoint"]] = None
+    _numeric_point: Optional[Optional["scout_compute_api_NumericPoint"]] = None
+    _log_point: Optional[Optional["scout_compute_api_LogPoint"]] = None
+    _range_value: Optional[Optional["scout_compute_api_Range"]] = None
+    _numeric: Optional["scout_compute_api_NumericPlot"] = None
+    _enum: Optional["scout_compute_api_EnumPlot"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'range': ConjureFieldDefinition('range', List[scout_compute_api_Range]),
+            'enum_point': ConjureFieldDefinition('enumPoint', OptionalTypeWrapper[scout_compute_api_EnumPoint]),
+            'numeric_point': ConjureFieldDefinition('numericPoint', OptionalTypeWrapper[scout_compute_api_NumericPoint]),
+            'log_point': ConjureFieldDefinition('logPoint', OptionalTypeWrapper[scout_compute_api_LogPoint]),
+            'range_value': ConjureFieldDefinition('rangeValue', OptionalTypeWrapper[scout_compute_api_Range]),
+            'numeric': ConjureFieldDefinition('numeric', scout_compute_api_NumericPlot),
+            'enum': ConjureFieldDefinition('enum', scout_compute_api_EnumPlot)
+        }
+
+    def __init__(
+            self,
+            range: Optional[List["scout_compute_api_Range"]] = None,
+            enum_point: Optional[Optional["scout_compute_api_EnumPoint"]] = None,
+            numeric_point: Optional[Optional["scout_compute_api_NumericPoint"]] = None,
+            log_point: Optional[Optional["scout_compute_api_LogPoint"]] = None,
+            range_value: Optional[Optional["scout_compute_api_Range"]] = None,
+            numeric: Optional["scout_compute_api_NumericPlot"] = None,
+            enum: Optional["scout_compute_api_EnumPlot"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (range is not None) + (enum_point is not None) + (numeric_point is not None) + (log_point is not None) + (range_value is not None) + (numeric is not None) + (enum is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if range is not None:
+                self._range = range
+                self._type = 'range'
+            if enum_point is not None:
+                self._enum_point = enum_point
+                self._type = 'enumPoint'
+            if numeric_point is not None:
+                self._numeric_point = numeric_point
+                self._type = 'numericPoint'
+            if log_point is not None:
+                self._log_point = log_point
+                self._type = 'logPoint'
+            if range_value is not None:
+                self._range_value = range_value
+                self._type = 'rangeValue'
+            if numeric is not None:
+                self._numeric = numeric
+                self._type = 'numeric'
+            if enum is not None:
+                self._enum = enum
+                self._type = 'enum'
+
+        elif type_of_union == 'range':
+            if range is None:
+                raise ValueError('a union value must not be None')
+            self._range = range
+            self._type = 'range'
+        elif type_of_union == 'enumPoint':
+            if enum_point is None:
+                raise ValueError('a union value must not be None')
+            self._enum_point = enum_point
+            self._type = 'enumPoint'
+        elif type_of_union == 'numericPoint':
+            if numeric_point is None:
+                raise ValueError('a union value must not be None')
+            self._numeric_point = numeric_point
+            self._type = 'numericPoint'
+        elif type_of_union == 'logPoint':
+            if log_point is None:
+                raise ValueError('a union value must not be None')
+            self._log_point = log_point
+            self._type = 'logPoint'
+        elif type_of_union == 'rangeValue':
+            if range_value is None:
+                raise ValueError('a union value must not be None')
+            self._range_value = range_value
+            self._type = 'rangeValue'
+        elif type_of_union == 'numeric':
+            if numeric is None:
+                raise ValueError('a union value must not be None')
+            self._numeric = numeric
+            self._type = 'numeric'
+        elif type_of_union == 'enum':
+            if enum is None:
+                raise ValueError('a union value must not be None')
+            self._enum = enum
+            self._type = 'enum'
+
+    @builtins.property
+    def range(self) -> Optional[List["scout_compute_api_Range"]]:
+        """
+        Merging can be done via dropping any old ranges (possibly truncating the last one) and adding these new 
+ranges, possibly merging them if they overlap or are adjacent.
+        """
+        return self._range
+
+    @builtins.property
+    def enum_point(self) -> Optional[Optional["scout_compute_api_EnumPoint"]]:
+        """
+        Merging can be done by keeping track of the applicable point present within the current window
+        """
+        return self._enum_point
+
+    @builtins.property
+    def numeric_point(self) -> Optional[Optional["scout_compute_api_NumericPoint"]]:
+        """
+        Merging can be done by keeping track of the applicable point present within the current window
+        """
+        return self._numeric_point
+
+    @builtins.property
+    def log_point(self) -> Optional[Optional["scout_compute_api_LogPoint"]]:
+        """
+        Merging can be done by keeping track of the applicable point present within the current window
+        """
+        return self._log_point
+
+    @builtins.property
+    def range_value(self) -> Optional[Optional["scout_compute_api_Range"]]:
+        """
+        Merging can be done by keeping track of the applicable range present within the current window, possibly
+merging ranges if they are overlap or are adjacent
+        """
+        return self._range_value
+
+    @builtins.property
+    def numeric(self) -> Optional["scout_compute_api_NumericPlot"]:
+        """
+        Merging be be done by dropping any old points and adding the new ones, accounting for overlaps
+        """
+        return self._numeric
+
+    @builtins.property
+    def enum(self) -> Optional["scout_compute_api_EnumPlot"]:
+        """
+        Merging be be done by dropping any old points and adding the new ones, accounting for overlaps
+        """
+        return self._enum
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, persistent_compute_api_ComputeNodeAppendResponseVisitor):
+            raise ValueError('{} is not an instance of persistent_compute_api_ComputeNodeAppendResponseVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'range' and self.range is not None:
+            return visitor._range(self.range)
+        if self._type == 'enumPoint' and self.enum_point is not None:
+            return visitor._enum_point(self.enum_point)
+        if self._type == 'numericPoint' and self.numeric_point is not None:
+            return visitor._numeric_point(self.numeric_point)
+        if self._type == 'logPoint' and self.log_point is not None:
+            return visitor._log_point(self.log_point)
+        if self._type == 'rangeValue' and self.range_value is not None:
+            return visitor._range_value(self.range_value)
+        if self._type == 'numeric' and self.numeric is not None:
+            return visitor._numeric(self.numeric)
+        if self._type == 'enum' and self.enum is not None:
+            return visitor._enum(self.enum)
+
+
+persistent_compute_api_ComputeNodeAppendResponse.__name__ = "ComputeNodeAppendResponse"
+persistent_compute_api_ComputeNodeAppendResponse.__qualname__ = "ComputeNodeAppendResponse"
+persistent_compute_api_ComputeNodeAppendResponse.__module__ = "nominal_api.persistent_compute_api"
+
+
+class persistent_compute_api_ComputeNodeAppendResponseVisitor:
+
+    @abstractmethod
+    def _range(self, range: List["scout_compute_api_Range"]) -> Any:
+        pass
+
+    @abstractmethod
+    def _enum_point(self, enum_point: Optional["scout_compute_api_EnumPoint"]) -> Any:
+        pass
+
+    @abstractmethod
+    def _numeric_point(self, numeric_point: Optional["scout_compute_api_NumericPoint"]) -> Any:
+        pass
+
+    @abstractmethod
+    def _log_point(self, log_point: Optional["scout_compute_api_LogPoint"]) -> Any:
+        pass
+
+    @abstractmethod
+    def _range_value(self, range_value: Optional["scout_compute_api_Range"]) -> Any:
+        pass
+
+    @abstractmethod
+    def _numeric(self, numeric: "scout_compute_api_NumericPlot") -> Any:
+        pass
+
+    @abstractmethod
+    def _enum(self, enum: "scout_compute_api_EnumPlot") -> Any:
+        pass
+
+
+persistent_compute_api_ComputeNodeAppendResponseVisitor.__name__ = "ComputeNodeAppendResponseVisitor"
+persistent_compute_api_ComputeNodeAppendResponseVisitor.__qualname__ = "ComputeNodeAppendResponseVisitor"
+persistent_compute_api_ComputeNodeAppendResponseVisitor.__module__ = "nominal_api.persistent_compute_api"
+
+
 class persistent_compute_api_FullResult(ConjureBeanType):
 
     @builtins.classmethod
@@ -11600,13 +12447,15 @@ class persistent_compute_api_SubscriptionOptions(ConjureBeanType):
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'min_delay': ConjureFieldDefinition('minDelay', persistent_compute_api_Milliseconds)
+            'min_delay': ConjureFieldDefinition('minDelay', persistent_compute_api_Milliseconds),
+            'allow_appends': ConjureFieldDefinition('allowAppends', OptionalTypeWrapper[bool])
         }
 
-    __slots__: List[str] = ['_min_delay']
+    __slots__: List[str] = ['_min_delay', '_allow_appends']
 
-    def __init__(self, min_delay: int) -> None:
+    def __init__(self, min_delay: int, allow_appends: Optional[bool] = None) -> None:
         self._min_delay = min_delay
+        self._allow_appends = allow_appends
 
     @builtins.property
     def min_delay(self) -> int:
@@ -11615,6 +12464,19 @@ class persistent_compute_api_SubscriptionOptions(ConjureBeanType):
         """
         return self._min_delay
 
+    @builtins.property
+    def allow_appends(self) -> Optional[bool]:
+        """
+        Can be set to `false` by the client to indicate that it doesn't support appends for this subscription
+and always wants to receive full results. Defaults to `false` if not set.
+The expectation is that clients should implement support for appends for any of the results covered in
+`ComputeNodeAppendResponse` and set this to `true` as quickly as possible. However, in order to support 
+adding new sub-types to `ComputeNodeAppendResponse` without breaking clients that haven't upgraded yet 
+and haven't yet added support for them, we default this to `false` and make clients opt-in as soon as they
+implement support.
+        """
+        return self._allow_appends
+
 
 persistent_compute_api_SubscriptionOptions.__name__ = "SubscriptionOptions"
 persistent_compute_api_SubscriptionOptions.__qualname__ = "SubscriptionOptions"
@@ -11623,41 +12485,58 @@ persistent_compute_api_SubscriptionOptions.__module__ = "nominal_api.persistent_
 
 class persistent_compute_api_SubscriptionUpdate(ConjureUnionType):
     _full: Optional["persistent_compute_api_FullResult"] = None
+    _append: Optional["persistent_compute_api_AppendResult"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'full': ConjureFieldDefinition('full', persistent_compute_api_FullResult)
+            'full': ConjureFieldDefinition('full', persistent_compute_api_FullResult),
+            'append': ConjureFieldDefinition('append', persistent_compute_api_AppendResult)
         }
 
     def __init__(
             self,
             full: Optional["persistent_compute_api_FullResult"] = None,
+            append: Optional["persistent_compute_api_AppendResult"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (full is not None) != 1:
+            if (full is not None) + (append is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if full is not None:
                 self._full = full
                 self._type = 'full'
+            if append is not None:
+                self._append = append
+                self._type = 'append'
 
         elif type_of_union == 'full':
             if full is None:
                 raise ValueError('a union value must not be None')
             self._full = full
             self._type = 'full'
+        elif type_of_union == 'append':
+            if append is None:
+                raise ValueError('a union value must not be None')
+            self._append = append
+            self._type = 'append'
 
     @builtins.property
     def full(self) -> Optional["persistent_compute_api_FullResult"]:
         return self._full
 
+    @builtins.property
+    def append(self) -> Optional["persistent_compute_api_AppendResult"]:
+        return self._append
+
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, persistent_compute_api_SubscriptionUpdateVisitor):
             raise ValueError('{} is not an instance of persistent_compute_api_SubscriptionUpdateVisitor'.format(visitor.__class__.__name__))
         if self._type == 'full' and self.full is not None:
             return visitor._full(self.full)
+        if self._type == 'append' and self.append is not None:
+            return visitor._append(self.append)
 
 
 persistent_compute_api_SubscriptionUpdate.__name__ = "SubscriptionUpdate"
@@ -11671,6 +12550,10 @@ class persistent_compute_api_SubscriptionUpdateVisitor:
     def _full(self, full: "persistent_compute_api_FullResult") -> Any:
         pass
 
+    @abstractmethod
+    def _append(self, append: "persistent_compute_api_AppendResult") -> Any:
+        pass
+
 
 persistent_compute_api_SubscriptionUpdateVisitor.__name__ = "SubscriptionUpdateVisitor"
 persistent_compute_api_SubscriptionUpdateVisitor.__qualname__ = "SubscriptionUpdateVisitor"
@@ -39939,13 +40822,15 @@ class scout_compute_api_SelectValue(ConjureUnionType):
     _first_point: Optional["scout_compute_api_Series"] = None
     _first_range: Optional["scout_compute_api_RangeSeries"] = None
     _last_point: Optional["scout_compute_api_Series"] = None
+    _last_range: Optional["scout_compute_api_RangeSeries"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'first_point': ConjureFieldDefinition('firstPoint', scout_compute_api_Series),
             'first_range': ConjureFieldDefinition('firstRange', scout_compute_api_RangeSeries),
-            'last_point': ConjureFieldDefinition('lastPoint', scout_compute_api_Series)
+            'last_point': ConjureFieldDefinition('lastPoint', scout_compute_api_Series),
+            'last_range': ConjureFieldDefinition('lastRange', scout_compute_api_RangeSeries)
         }
 
     def __init__(
@@ -39953,10 +40838,11 @@ class scout_compute_api_SelectValue(ConjureUnionType):
             first_point: Optional["scout_compute_api_Series"] = None,
             first_range: Optional["scout_compute_api_RangeSeries"] = None,
             last_point: Optional["scout_compute_api_Series"] = None,
+            last_range: Optional["scout_compute_api_RangeSeries"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (first_point is not None) + (first_range is not None) + (last_point is not None) != 1:
+            if (first_point is not None) + (first_range is not None) + (last_point is not None) + (last_range is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if first_point is not None:
@@ -39968,6 +40854,9 @@ class scout_compute_api_SelectValue(ConjureUnionType):
             if last_point is not None:
                 self._last_point = last_point
                 self._type = 'lastPoint'
+            if last_range is not None:
+                self._last_range = last_range
+                self._type = 'lastRange'
 
         elif type_of_union == 'firstPoint':
             if first_point is None:
@@ -39984,6 +40873,11 @@ class scout_compute_api_SelectValue(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._last_point = last_point
             self._type = 'lastPoint'
+        elif type_of_union == 'lastRange':
+            if last_range is None:
+                raise ValueError('a union value must not be None')
+            self._last_range = last_range
+            self._type = 'lastRange'
 
     @builtins.property
     def first_point(self) -> Optional["scout_compute_api_Series"]:
@@ -39997,6 +40891,10 @@ class scout_compute_api_SelectValue(ConjureUnionType):
     def last_point(self) -> Optional["scout_compute_api_Series"]:
         return self._last_point
 
+    @builtins.property
+    def last_range(self) -> Optional["scout_compute_api_RangeSeries"]:
+        return self._last_range
+
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, scout_compute_api_SelectValueVisitor):
             raise ValueError('{} is not an instance of scout_compute_api_SelectValueVisitor'.format(visitor.__class__.__name__))
@@ -40006,6 +40904,8 @@ class scout_compute_api_SelectValue(ConjureUnionType):
             return visitor._first_range(self.first_range)
         if self._type == 'lastPoint' and self.last_point is not None:
             return visitor._last_point(self.last_point)
+        if self._type == 'lastRange' and self.last_range is not None:
+            return visitor._last_range(self.last_range)
 
 
 scout_compute_api_SelectValue.__name__ = "SelectValue"
@@ -40027,6 +40927,10 @@ class scout_compute_api_SelectValueVisitor:
     def _last_point(self, last_point: "scout_compute_api_Series") -> Any:
         pass
 
+    @abstractmethod
+    def _last_range(self, last_range: "scout_compute_api_RangeSeries") -> Any:
+        pass
+
 
 scout_compute_api_SelectValueVisitor.__name__ = "SelectValueVisitor"
 scout_compute_api_SelectValueVisitor.__qualname__ = "SelectValueVisitor"
@@ -48986,13 +49890,15 @@ class scout_compute_resolved_api_SelectValueNode(ConjureUnionType):
     _first_point: Optional["scout_compute_resolved_api_SeriesNode"] = None
     _first_range: Optional["scout_compute_resolved_api_RangesNode"] = None
     _last_point: Optional["scout_compute_resolved_api_SeriesNode"] = None
+    _last_range: Optional["scout_compute_resolved_api_RangesNode"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'first_point': ConjureFieldDefinition('firstPoint', scout_compute_resolved_api_SeriesNode),
             'first_range': ConjureFieldDefinition('firstRange', scout_compute_resolved_api_RangesNode),
-            'last_point': ConjureFieldDefinition('lastPoint', scout_compute_resolved_api_SeriesNode)
+            'last_point': ConjureFieldDefinition('lastPoint', scout_compute_resolved_api_SeriesNode),
+            'last_range': ConjureFieldDefinition('lastRange', scout_compute_resolved_api_RangesNode)
         }
 
     def __init__(
@@ -49000,10 +49906,11 @@ class scout_compute_resolved_api_SelectValueNode(ConjureUnionType):
             first_point: Optional["scout_compute_resolved_api_SeriesNode"] = None,
             first_range: Optional["scout_compute_resolved_api_RangesNode"] = None,
             last_point: Optional["scout_compute_resolved_api_SeriesNode"] = None,
+            last_range: Optional["scout_compute_resolved_api_RangesNode"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (first_point is not None) + (first_range is not None) + (last_point is not None) != 1:
+            if (first_point is not None) + (first_range is not None) + (last_point is not None) + (last_range is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if first_point is not None:
@@ -49015,6 +49922,9 @@ class scout_compute_resolved_api_SelectValueNode(ConjureUnionType):
             if last_point is not None:
                 self._last_point = last_point
                 self._type = 'lastPoint'
+            if last_range is not None:
+                self._last_range = last_range
+                self._type = 'lastRange'
 
         elif type_of_union == 'firstPoint':
             if first_point is None:
@@ -49031,6 +49941,11 @@ class scout_compute_resolved_api_SelectValueNode(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._last_point = last_point
             self._type = 'lastPoint'
+        elif type_of_union == 'lastRange':
+            if last_range is None:
+                raise ValueError('a union value must not be None')
+            self._last_range = last_range
+            self._type = 'lastRange'
 
     @builtins.property
     def first_point(self) -> Optional["scout_compute_resolved_api_SeriesNode"]:
@@ -49044,6 +49959,10 @@ class scout_compute_resolved_api_SelectValueNode(ConjureUnionType):
     def last_point(self) -> Optional["scout_compute_resolved_api_SeriesNode"]:
         return self._last_point
 
+    @builtins.property
+    def last_range(self) -> Optional["scout_compute_resolved_api_RangesNode"]:
+        return self._last_range
+
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, scout_compute_resolved_api_SelectValueNodeVisitor):
             raise ValueError('{} is not an instance of scout_compute_resolved_api_SelectValueNodeVisitor'.format(visitor.__class__.__name__))
@@ -49053,6 +49972,8 @@ class scout_compute_resolved_api_SelectValueNode(ConjureUnionType):
             return visitor._first_range(self.first_range)
         if self._type == 'lastPoint' and self.last_point is not None:
             return visitor._last_point(self.last_point)
+        if self._type == 'lastRange' and self.last_range is not None:
+            return visitor._last_range(self.last_range)
 
 
 scout_compute_resolved_api_SelectValueNode.__name__ = "SelectValueNode"
@@ -49074,6 +49995,10 @@ class scout_compute_resolved_api_SelectValueNodeVisitor:
     def _last_point(self, last_point: "scout_compute_resolved_api_SeriesNode") -> Any:
         pass
 
+    @abstractmethod
+    def _last_range(self, last_range: "scout_compute_resolved_api_RangesNode") -> Any:
+        pass
+
 
 scout_compute_resolved_api_SelectValueNodeVisitor.__name__ = "SelectValueNodeVisitor"
 scout_compute_resolved_api_SelectValueNodeVisitor.__qualname__ = "SelectValueNodeVisitor"
@@ -76118,6 +77043,8 @@ upload_api_UploadService.__qualname__ = "UploadService"
 upload_api_UploadService.__module__ = "nominal_api.upload_api"
 
 
+api_ColumnName = str
+
 api_Label = str
 
 timeseries_archetype_api_SeriesArchetypeName = str
@@ -76148,6 +77075,8 @@ api_rids_VideoFileRid = str
 
 api_Unit = str
 
+ingest_workflow_api_McapTopicName = str
+
 scout_versioning_api_BranchRid = str
 
 datasource_DatasetFileId = str
@@ -76314,8 +77243,6 @@ scout_datareview_api_AutomaticCheckEvaluationRid = str
 
 scout_compute_api_ErrorType = str
 
-ingest_api_ExtractorInputName = str
-
 comments_api_ResourceRid = str
 
 scout_rids_api_FunctionLineageRid = str