nominal-api 0.609.0__py3-none-any.whl → 0.611.0__py3-none-any.whl

nominal_api/_impl.py

@@ -6538,6 +6538,63 @@ ingest_api_AsyncHandle.__qualname__ = "AsyncHandle"
 ingest_api_AsyncHandle.__module__ = "nominal_api.ingest_api"
 
 
+class ingest_api_Authentication(ConjureUnionType):
+    """Authentication methods for Docker registries."""
+    _user_and_password: Optional["ingest_api_UserAndPasswordAuthentication"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'user_and_password': ConjureFieldDefinition('userAndPassword', ingest_api_UserAndPasswordAuthentication)
+        }
+
+    def __init__(
+            self,
+            user_and_password: Optional["ingest_api_UserAndPasswordAuthentication"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (user_and_password is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if user_and_password is not None:
+                self._user_and_password = user_and_password
+                self._type = 'userAndPassword'
+
+        elif type_of_union == 'userAndPassword':
+            if user_and_password is None:
+                raise ValueError('a union value must not be None')
+            self._user_and_password = user_and_password
+            self._type = 'userAndPassword'
+
+    @builtins.property
+    def user_and_password(self) -> Optional["ingest_api_UserAndPasswordAuthentication"]:
+        return self._user_and_password
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, ingest_api_AuthenticationVisitor):
+            raise ValueError('{} is not an instance of ingest_api_AuthenticationVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'userAndPassword' and self.user_and_password is not None:
+            return visitor._user_and_password(self.user_and_password)
+
+
+ingest_api_Authentication.__name__ = "Authentication"
+ingest_api_Authentication.__qualname__ = "Authentication"
+ingest_api_Authentication.__module__ = "nominal_api.ingest_api"
+
+
+class ingest_api_AuthenticationVisitor:
+
+    @abstractmethod
+    def _user_and_password(self, user_and_password: "ingest_api_UserAndPasswordAuthentication") -> Any:
+        pass
+
+
+ingest_api_AuthenticationVisitor.__name__ = "AuthenticationVisitor"
+ingest_api_AuthenticationVisitor.__qualname__ = "AuthenticationVisitor"
+ingest_api_AuthenticationVisitor.__module__ = "nominal_api.ingest_api"
+
+
 class ingest_api_ChannelConfig(ConjureBeanType):
 
     @builtins.classmethod
@@ -6587,63 +6644,310 @@ ingest_api_CompleteMultipartUploadResponse.__qualname__ = "CompleteMultipartUplo
 ingest_api_CompleteMultipartUploadResponse.__module__ = "nominal_api.ingest_api"
 
 
-class ingest_api_CsvOpts(ConjureBeanType):
+class ingest_api_ContainerizedExtractor(ConjureBeanType):
     """
-    Options for ingesting csv files.  Supported file formats include .csv, .csv.gz
+    Represents a containerized extractor that processes input files using a container.
     """
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'source': ConjureFieldDefinition('source', ingest_api_IngestSource),
-            'target': ConjureFieldDefinition('target', ingest_api_DatasetIngestTarget),
-            'timestamp_metadata': ConjureFieldDefinition('timestampMetadata', ingest_api_TimestampMetadata),
-            'channel_prefix': ConjureFieldDefinition('channelPrefix', ingest_api_ChannelPrefix),
-            'tag_keys_from_columns': ConjureFieldDefinition('tagKeysFromColumns', OptionalTypeWrapper[List[api_TagName]]),
-            'additional_file_tags': ConjureFieldDefinition('additionalFileTags', OptionalTypeWrapper[Dict[api_TagName, api_TagValue]])
+            'rid': ConjureFieldDefinition('rid', ingest_api_ContainerizedExtractorRid),
+            'name': ConjureFieldDefinition('name', str),
+            'description': ConjureFieldDefinition('description', OptionalTypeWrapper[str]),
+            'image': ConjureFieldDefinition('image', ingest_api_DockerImageSource),
+            'inputs': ConjureFieldDefinition('inputs', List[ingest_api_FileExtractionInput]),
+            'properties': ConjureFieldDefinition('properties', Dict[api_PropertyName, api_PropertyValue]),
+            'labels': ConjureFieldDefinition('labels', List[api_Label]),
+            'created_at': ConjureFieldDefinition('createdAt', str),
+            'is_archived': ConjureFieldDefinition('isArchived', bool)
         }
 
-    __slots__: List[str] = ['_source', '_target', '_timestamp_metadata', '_channel_prefix', '_tag_keys_from_columns', '_additional_file_tags']
+    __slots__: List[str] = ['_rid', '_name', '_description', '_image', '_inputs', '_properties', '_labels', '_created_at', '_is_archived']
 
-    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:
-        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._additional_file_tags = additional_file_tags
+    def __init__(self, created_at: str, image: "ingest_api_DockerImageSource", inputs: List["ingest_api_FileExtractionInput"], is_archived: bool, labels: List[str], name: str, properties: Dict[str, str], rid: str, description: Optional[str] = None) -> None:
+        self._rid = rid
+        self._name = name
+        self._description = description
+        self._image = image
+        self._inputs = inputs
+        self._properties = properties
+        self._labels = labels
+        self._created_at = created_at
+        self._is_archived = is_archived
 
     @builtins.property
-    def source(self) -> "ingest_api_IngestSource":
-        return self._source
+    def rid(self) -> str:
+        """
+        Unique resource identifier for the extractor.
+        """
+        return self._rid
 
     @builtins.property
-    def target(self) -> "ingest_api_DatasetIngestTarget":
-        return self._target
+    def name(self) -> str:
+        """
+        The name of the extractor as defined by the user.
+        """
+        return self._name
 
     @builtins.property
-    def timestamp_metadata(self) -> "ingest_api_TimestampMetadata":
-        return self._timestamp_metadata
+    def description(self) -> Optional[str]:
+        """
+        Optional description of the extractor.
+        """
+        return self._description
 
     @builtins.property
-    def channel_prefix(self) -> Optional[str]:
-        return self._channel_prefix
+    def image(self) -> "ingest_api_DockerImageSource":
+        """
+        Container image used to run the extractor.
+        """
+        return self._image
 
     @builtins.property
-    def tag_keys_from_columns(self) -> Optional[List[str]]:
-        return self._tag_keys_from_columns
+    def inputs(self) -> List["ingest_api_FileExtractionInput"]:
+        """
+        The input files that this extractor requires, mapped to environment variables that store the path to the file.
+        """
+        return self._inputs
 
     @builtins.property
-    def additional_file_tags(self) -> Optional[Dict[str, str]]:
-        return self._additional_file_tags
+    def properties(self) -> Dict[str, str]:
+        """
+        Additional properties associated with this extractor.
+        """
+        return self._properties
+
+    @builtins.property
+    def labels(self) -> List[str]:
+        """
+        Set of labels applied to this extractor.
+        """
+        return self._labels
 
+    @builtins.property
+    def created_at(self) -> str:
+        """
+        Timestamp when this extractor was created.
+        """
+        return self._created_at
 
-ingest_api_CsvOpts.__name__ = "CsvOpts"
-ingest_api_CsvOpts.__qualname__ = "CsvOpts"
-ingest_api_CsvOpts.__module__ = "nominal_api.ingest_api"
+    @builtins.property
+    def is_archived(self) -> bool:
+        """
+        Whether this extractor is archived.
+        """
+        return self._is_archived
+
+
+ingest_api_ContainerizedExtractor.__name__ = "ContainerizedExtractor"
+ingest_api_ContainerizedExtractor.__qualname__ = "ContainerizedExtractor"
+ingest_api_ContainerizedExtractor.__module__ = "nominal_api.ingest_api"
+
+
+class ingest_api_ContainerizedExtractorService(Service):
+    """
+    The Containerized Extractor service provides functionality for creating, updating, and archiving containerized extractors.
+    """
+
+    def register_containerized_extractor(self, auth_header: str, request: "ingest_api_RegisterContainerizedExtractorRequest") -> "ingest_api_RegisterContainerizedExtractorResponse":
+        """
+        Registers a containerized extractor for a given set of containerized files.
+        """
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+        }
+
+        _json: Any = ConjureEncoder().default(request)
+
+        _path = '/extractors/v1/container'
+        _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(), ingest_api_RegisterContainerizedExtractorResponse, self._return_none_for_unknown_union_types)
+
+    def get_containerized_extractor(self, auth_header: str, extractor_rid: str) -> "ingest_api_ContainerizedExtractor":
+        """
+        Get a containerized extractor by its RID.
+        """
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+            'extractorRid': extractor_rid,
+        }
+
+        _json: Any = None
+
+        _path = '/extractors/v1/container/{extractorRid}'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'GET',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        _decoder = ConjureDecoder()
+        return _decoder.decode(_response.json(), ingest_api_ContainerizedExtractor, self._return_none_for_unknown_union_types)
+
+    def search_containerized_extractors(self, auth_header: str, request: "ingest_api_SearchContainerizedExtractorsRequest") -> List["ingest_api_ContainerizedExtractor"]:
+        """
+        Search for containerized extractors based on query parameters.
+        """
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+        }
+
+        _json: Any = ConjureEncoder().default(request)
+
+        _path = '/extractors/v1/container/search'
+        _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(), List[ingest_api_ContainerizedExtractor], self._return_none_for_unknown_union_types)
+
+    def update_containerized_extractor(self, auth_header: str, extractor_rid: str, request: "ingest_api_UpdateContainerizedExtractorRequest") -> "ingest_api_ContainerizedExtractor":
+        """
+        Update a containerized extractor. Only the fields that are set in the request will be updated.
+        """
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+            'extractorRid': extractor_rid,
+        }
+
+        _json: Any = ConjureEncoder().default(request)
+
+        _path = '/extractors/v1/container/{extractorRid}'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'PUT',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        _decoder = ConjureDecoder()
+        return _decoder.decode(_response.json(), ingest_api_ContainerizedExtractor, self._return_none_for_unknown_union_types)
+
+    def archive_containerized_extractor(self, auth_header: str, extractor_rid: str) -> None:
+        """
+        Archive a containerized extractor.
+        """
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+            'extractorRid': extractor_rid,
+        }
+
+        _json: Any = None
+
+        _path = '/extractors/v1/container/{extractorRid}/archive'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'PUT',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        return
+
+    def unarchive_containerized_extractor(self, auth_header: str, extractor_rid: str) -> None:
+        """
+        Unarchive a containerized extractor.
+        """
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+            'extractorRid': extractor_rid,
+        }
+
+        _json: Any = None
+
+        _path = '/extractors/v1/container/{extractorRid}/unarchive'
+        _path = _path.format(**_path_params)
 
+        _response: Response = self._request(
+            'PUT',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
 
-class ingest_api_CustomOpts(ConjureBeanType):
+        return
+
+
+ingest_api_ContainerizedExtractorService.__name__ = "ContainerizedExtractorService"
+ingest_api_ContainerizedExtractorService.__qualname__ = "ContainerizedExtractorService"
+ingest_api_ContainerizedExtractorService.__module__ = "nominal_api.ingest_api"
+
+
+class ingest_api_ContainerizedOpts(ConjureBeanType):
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
@@ -6679,9 +6983,65 @@ class ingest_api_CustomOpts(ConjureBeanType):
         return self._target
 
 
-ingest_api_CustomOpts.__name__ = "CustomOpts"
-ingest_api_CustomOpts.__qualname__ = "CustomOpts"
-ingest_api_CustomOpts.__module__ = "nominal_api.ingest_api"
+ingest_api_ContainerizedOpts.__name__ = "ContainerizedOpts"
+ingest_api_ContainerizedOpts.__qualname__ = "ContainerizedOpts"
+ingest_api_ContainerizedOpts.__module__ = "nominal_api.ingest_api"
+
+
+class ingest_api_CsvOpts(ConjureBeanType):
+    """
+    Options for ingesting csv files.  Supported file formats include .csv, .csv.gz
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'source': ConjureFieldDefinition('source', ingest_api_IngestSource),
+            'target': ConjureFieldDefinition('target', ingest_api_DatasetIngestTarget),
+            'timestamp_metadata': ConjureFieldDefinition('timestampMetadata', ingest_api_TimestampMetadata),
+            'channel_prefix': ConjureFieldDefinition('channelPrefix', ingest_api_ChannelPrefix),
+            'tag_keys_from_columns': ConjureFieldDefinition('tagKeysFromColumns', OptionalTypeWrapper[List[api_TagName]]),
+            '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']
+
+    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:
+        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._additional_file_tags = additional_file_tags
+
+    @builtins.property
+    def source(self) -> "ingest_api_IngestSource":
+        return self._source
+
+    @builtins.property
+    def target(self) -> "ingest_api_DatasetIngestTarget":
+        return self._target
+
+    @builtins.property
+    def timestamp_metadata(self) -> "ingest_api_TimestampMetadata":
+        return self._timestamp_metadata
+
+    @builtins.property
+    def channel_prefix(self) -> Optional[str]:
+        return self._channel_prefix
+
+    @builtins.property
+    def tag_keys_from_columns(self) -> Optional[List[str]]:
+        return self._tag_keys_from_columns
+
+    @builtins.property
+    def additional_file_tags(self) -> Optional[Dict[str, str]]:
+        return self._additional_file_tags
+
+
+ingest_api_CsvOpts.__name__ = "CsvOpts"
+ingest_api_CsvOpts.__qualname__ = "CsvOpts"
+ingest_api_CsvOpts.__module__ = "nominal_api.ingest_api"
 
 
 class ingest_api_CustomTimestamp(ConjureBeanType):
@@ -7040,6 +7400,62 @@ ingest_api_DeprecatedTriggerIngest.__qualname__ = "DeprecatedTriggerIngest"
 ingest_api_DeprecatedTriggerIngest.__module__ = "nominal_api.ingest_api"
 
 
+class ingest_api_DockerImageSource(ConjureBeanType):
+    """
+    Docker container image source definition.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'registry': ConjureFieldDefinition('registry', str),
+            'repository': ConjureFieldDefinition('repository', str),
+            'tag': ConjureFieldDefinition('tag', str),
+            'authentication': ConjureFieldDefinition('authentication', OptionalTypeWrapper[ingest_api_Authentication])
+        }
+
+    __slots__: List[str] = ['_registry', '_repository', '_tag', '_authentication']
+
+    def __init__(self, registry: str, repository: str, tag: str, authentication: Optional["ingest_api_Authentication"] = None) -> None:
+        self._registry = registry
+        self._repository = repository
+        self._tag = tag
+        self._authentication = authentication
+
+    @builtins.property
+    def registry(self) -> str:
+        """
+        The container registry where the image is hosted.
+        """
+        return self._registry
+
+    @builtins.property
+    def repository(self) -> str:
+        """
+        The repository name of the image.
+        """
+        return self._repository
+
+    @builtins.property
+    def tag(self) -> str:
+        """
+        The tag of the image to use.
+        """
+        return self._tag
+
+    @builtins.property
+    def authentication(self) -> Optional["ingest_api_Authentication"]:
+        """
+        Optional authentication for accessing private container registries.
+        """
+        return self._authentication
+
+
+ingest_api_DockerImageSource.__name__ = "DockerImageSource"
+ingest_api_DockerImageSource.__qualname__ = "DockerImageSource"
+ingest_api_DockerImageSource.__module__ = "nominal_api.ingest_api"
+
+
 class ingest_api_EpochTimestamp(ConjureBeanType):
 
     @builtins.classmethod
@@ -7121,6 +7537,62 @@ ingest_api_ExistingVideoIngestDestination.__qualname__ = "ExistingVideoIngestDes
 ingest_api_ExistingVideoIngestDestination.__module__ = "nominal_api.ingest_api"
 
 
+class ingest_api_FileExtractionInput(ConjureBeanType):
+    """
+    Defines an input file to be provided to the extractor.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'environment_variable': ConjureFieldDefinition('environmentVariable', ingest_api_EnvironmentVariable),
+            'name': ConjureFieldDefinition('name', str),
+            'description': ConjureFieldDefinition('description', OptionalTypeWrapper[str]),
+            'regex': ConjureFieldDefinition('regex', OptionalTypeWrapper[str])
+        }
+
+    __slots__: List[str] = ['_environment_variable', '_name', '_description', '_regex']
+
+    def __init__(self, environment_variable: str, name: str, description: Optional[str] = None, regex: Optional[str] = None) -> None:
+        self._environment_variable = environment_variable
+        self._name = name
+        self._description = description
+        self._regex = regex
+
+    @builtins.property
+    def environment_variable(self) -> str:
+        """
+        The environment variable that stores the path to the input file.
+        """
+        return self._environment_variable
+
+    @builtins.property
+    def name(self) -> str:
+        """
+        Name of the input file which users will be prompted with
+        """
+        return self._name
+
+    @builtins.property
+    def description(self) -> Optional[str]:
+        """
+        Description of the input file which users will be prompted with
+        """
+        return self._description
+
+    @builtins.property
+    def regex(self) -> Optional[str]:
+        """
+        Optionally filter files by regex for file selection. Will not be enforced at runtime, so containers need to handle their own validation.
+        """
+        return self._regex
+
+
+ingest_api_FileExtractionInput.__name__ = "FileExtractionInput"
+ingest_api_FileExtractionInput.__qualname__ = "FileExtractionInput"
+ingest_api_FileExtractionInput.__module__ = "nominal_api.ingest_api"
+
+
 class ingest_api_GcsIngestSource(ConjureBeanType):
 
     @builtins.classmethod
@@ -7144,6 +7616,52 @@ ingest_api_GcsIngestSource.__qualname__ = "GcsIngestSource"
 ingest_api_GcsIngestSource.__module__ = "nominal_api.ingest_api"
 
 
+class ingest_api_GetContainerizedExtractorsRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'extractor_rids': ConjureFieldDefinition('extractorRids', List[ingest_api_ContainerizedExtractorRid])
+        }
+
+    __slots__: List[str] = ['_extractor_rids']
+
+    def __init__(self, extractor_rids: List[str]) -> None:
+        self._extractor_rids = extractor_rids
+
+    @builtins.property
+    def extractor_rids(self) -> List[str]:
+        return self._extractor_rids
+
+
+ingest_api_GetContainerizedExtractorsRequest.__name__ = "GetContainerizedExtractorsRequest"
+ingest_api_GetContainerizedExtractorsRequest.__qualname__ = "GetContainerizedExtractorsRequest"
+ingest_api_GetContainerizedExtractorsRequest.__module__ = "nominal_api.ingest_api"
+
+
+class ingest_api_GetContainerizedExtractorsResponse(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'extractors': ConjureFieldDefinition('extractors', List[ingest_api_ContainerizedExtractor])
+        }
+
+    __slots__: List[str] = ['_extractors']
+
+    def __init__(self, extractors: List["ingest_api_ContainerizedExtractor"]) -> None:
+        self._extractors = extractors
+
+    @builtins.property
+    def extractors(self) -> List["ingest_api_ContainerizedExtractor"]:
+        return self._extractors
+
+
+ingest_api_GetContainerizedExtractorsResponse.__name__ = "GetContainerizedExtractorsResponse"
+ingest_api_GetContainerizedExtractorsResponse.__qualname__ = "GetContainerizedExtractorsResponse"
+ingest_api_GetContainerizedExtractorsResponse.__module__ = "nominal_api.ingest_api"
+
+
 class ingest_api_IngestDataSource(ConjureUnionType):
     _existing_data_source: Optional[str] = None
     _new_data_source: Optional["ingest_api_DeprecatedNewDataSource"] = None
@@ -7543,7 +8061,7 @@ class ingest_api_IngestOptions(ConjureUnionType):
     _csv: Optional["ingest_api_CsvOpts"] = None
     _parquet: Optional["ingest_api_ParquetOpts"] = None
     _video: Optional["ingest_api_VideoOpts"] = None
-    _custom: Optional["ingest_api_CustomOpts"] = None
+    _containerized: Optional["ingest_api_ContainerizedOpts"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
@@ -7554,7 +8072,7 @@ class ingest_api_IngestOptions(ConjureUnionType):
             'csv': ConjureFieldDefinition('csv', ingest_api_CsvOpts),
             'parquet': ConjureFieldDefinition('parquet', ingest_api_ParquetOpts),
             'video': ConjureFieldDefinition('video', ingest_api_VideoOpts),
-            'custom': ConjureFieldDefinition('custom', ingest_api_CustomOpts)
+            'containerized': ConjureFieldDefinition('containerized', ingest_api_ContainerizedOpts)
         }
 
     def __init__(
@@ -7565,11 +8083,11 @@ class ingest_api_IngestOptions(ConjureUnionType):
             csv: Optional["ingest_api_CsvOpts"] = None,
             parquet: Optional["ingest_api_ParquetOpts"] = None,
             video: Optional["ingest_api_VideoOpts"] = None,
-            custom: Optional["ingest_api_CustomOpts"] = None,
+            containerized: Optional["ingest_api_ContainerizedOpts"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (dataflash is not None) + (mcap_protobuf_timeseries is not None) + (journal_json is not None) + (csv is not None) + (parquet is not None) + (video is not None) + (custom is not None) != 1:
+            if (dataflash is not None) + (mcap_protobuf_timeseries is not None) + (journal_json is not None) + (csv is not None) + (parquet is not None) + (video is not None) + (containerized is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if dataflash is not None:
@@ -7590,9 +8108,9 @@ class ingest_api_IngestOptions(ConjureUnionType):
             if video is not None:
                 self._video = video
                 self._type = 'video'
-            if custom is not None:
-                self._custom = custom
-                self._type = 'custom'
+            if containerized is not None:
+                self._containerized = containerized
+                self._type = 'containerized'
 
         elif type_of_union == 'dataflash':
             if dataflash is None:
@@ -7624,11 +8142,11 @@ class ingest_api_IngestOptions(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._video = video
             self._type = 'video'
-        elif type_of_union == 'custom':
-            if custom is None:
+        elif type_of_union == 'containerized':
+            if containerized is None:
                 raise ValueError('a union value must not be None')
-            self._custom = custom
-            self._type = 'custom'
+            self._containerized = containerized
+            self._type = 'containerized'
 
     @builtins.property
     def dataflash(self) -> Optional["ingest_api_DataflashOpts"]:
@@ -7655,8 +8173,8 @@ class ingest_api_IngestOptions(ConjureUnionType):
         return self._video
 
     @builtins.property
-    def custom(self) -> Optional["ingest_api_CustomOpts"]:
-        return self._custom
+    def containerized(self) -> Optional["ingest_api_ContainerizedOpts"]:
+        return self._containerized
 
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, ingest_api_IngestOptionsVisitor):
@@ -7673,8 +8191,8 @@ class ingest_api_IngestOptions(ConjureUnionType):
             return visitor._parquet(self.parquet)
         if self._type == 'video' and self.video is not None:
             return visitor._video(self.video)
-        if self._type == 'custom' and self.custom is not None:
-            return visitor._custom(self.custom)
+        if self._type == 'containerized' and self.containerized is not None:
+            return visitor._containerized(self.containerized)
 
 
 ingest_api_IngestOptions.__name__ = "IngestOptions"
@@ -7709,7 +8227,7 @@ class ingest_api_IngestOptionsVisitor:
         pass
 
     @abstractmethod
-    def _custom(self, custom: "ingest_api_CustomOpts") -> Any:
+    def _containerized(self, containerized: "ingest_api_ContainerizedOpts") -> Any:
         pass
 
 
@@ -9466,6 +9984,94 @@ ingest_api_PartWithSize.__qualname__ = "PartWithSize"
 ingest_api_PartWithSize.__module__ = "nominal_api.ingest_api"
 
 
+class ingest_api_RegisterContainerizedExtractorRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'name': ConjureFieldDefinition('name', str),
+            'description': ConjureFieldDefinition('description', OptionalTypeWrapper[str]),
+            'image': ConjureFieldDefinition('image', ingest_api_DockerImageSource),
+            'inputs': ConjureFieldDefinition('inputs', List[ingest_api_FileExtractionInput]),
+            'properties': ConjureFieldDefinition('properties', Dict[api_PropertyName, api_PropertyValue]),
+            'labels': ConjureFieldDefinition('labels', List[api_Label]),
+            'workspace': ConjureFieldDefinition('workspace', api_rids_WorkspaceRid)
+        }
+
+    __slots__: List[str] = ['_name', '_description', '_image', '_inputs', '_properties', '_labels', '_workspace']
+
+    def __init__(self, image: "ingest_api_DockerImageSource", inputs: List["ingest_api_FileExtractionInput"], labels: List[str], name: str, properties: Dict[str, str], workspace: str, description: Optional[str] = None) -> None:
+        self._name = name
+        self._description = description
+        self._image = image
+        self._inputs = inputs
+        self._properties = properties
+        self._labels = labels
+        self._workspace = workspace
+
+    @builtins.property
+    def name(self) -> str:
+        return self._name
+
+    @builtins.property
+    def description(self) -> Optional[str]:
+        return self._description
+
+    @builtins.property
+    def image(self) -> "ingest_api_DockerImageSource":
+        return self._image
+
+    @builtins.property
+    def inputs(self) -> List["ingest_api_FileExtractionInput"]:
+        """
+        payload must match input defined in containerized extraction
+        """
+        return self._inputs
+
+    @builtins.property
+    def properties(self) -> Dict[str, str]:
+        return self._properties
+
+    @builtins.property
+    def labels(self) -> List[str]:
+        return self._labels
+
+    @builtins.property
+    def workspace(self) -> str:
+        """
+        The workspace in which to create the extractor
+        """
+        return self._workspace
+
+
+ingest_api_RegisterContainerizedExtractorRequest.__name__ = "RegisterContainerizedExtractorRequest"
+ingest_api_RegisterContainerizedExtractorRequest.__qualname__ = "RegisterContainerizedExtractorRequest"
+ingest_api_RegisterContainerizedExtractorRequest.__module__ = "nominal_api.ingest_api"
+
+
+class ingest_api_RegisterContainerizedExtractorResponse(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'extractor_rid': ConjureFieldDefinition('extractorRid', ingest_api_ContainerizedExtractorRid)
+        }
+
+    __slots__: List[str] = ['_extractor_rid']
+
+    def __init__(self, extractor_rid: str) -> None:
+        self._extractor_rid = extractor_rid
+
+    @builtins.property
+    def extractor_rid(self) -> str:
+        return self._extractor_rid
+
+
+ingest_api_RegisterContainerizedExtractorResponse.__name__ = "RegisterContainerizedExtractorResponse"
+ingest_api_RegisterContainerizedExtractorResponse.__qualname__ = "RegisterContainerizedExtractorResponse"
+ingest_api_RegisterContainerizedExtractorResponse.__module__ = "nominal_api.ingest_api"
+
+
 class ingest_api_RelativeTimestamp(ConjureBeanType):
 
     @builtins.classmethod
@@ -9625,6 +10231,190 @@ ingest_api_ScaleParameterVisitor.__qualname__ = "ScaleParameterVisitor"
 ingest_api_ScaleParameterVisitor.__module__ = "nominal_api.ingest_api"
 
 
+class ingest_api_SearchContainerizedExtractorsQuery(ConjureUnionType):
+    _search_text: Optional[str] = None
+    _label: Optional[str] = None
+    _property: Optional["api_Property"] = None
+    _and_: Optional[List["ingest_api_SearchContainerizedExtractorsQuery"]] = None
+    _or_: Optional[List["ingest_api_SearchContainerizedExtractorsQuery"]] = None
+    _workspace: Optional[str] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'search_text': ConjureFieldDefinition('searchText', str),
+            'label': ConjureFieldDefinition('label', api_Label),
+            'property': ConjureFieldDefinition('property', api_Property),
+            'and_': ConjureFieldDefinition('and', List[ingest_api_SearchContainerizedExtractorsQuery]),
+            'or_': ConjureFieldDefinition('or', List[ingest_api_SearchContainerizedExtractorsQuery]),
+            'workspace': ConjureFieldDefinition('workspace', api_rids_WorkspaceRid)
+        }
+
+    def __init__(
+            self,
+            search_text: Optional[str] = None,
+            label: Optional[str] = None,
+            property: Optional["api_Property"] = None,
+            and_: Optional[List["ingest_api_SearchContainerizedExtractorsQuery"]] = None,
+            or_: Optional[List["ingest_api_SearchContainerizedExtractorsQuery"]] = None,
+            workspace: Optional[str] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (search_text is not None) + (label is not None) + (property is not None) + (and_ is not None) + (or_ is not None) + (workspace is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if search_text is not None:
+                self._search_text = search_text
+                self._type = 'searchText'
+            if label is not None:
+                self._label = label
+                self._type = 'label'
+            if property is not None:
+                self._property = property
+                self._type = 'property'
+            if and_ is not None:
+                self._and_ = and_
+                self._type = 'and'
+            if or_ is not None:
+                self._or_ = or_
+                self._type = 'or'
+            if workspace is not None:
+                self._workspace = workspace
+                self._type = 'workspace'
+
+        elif type_of_union == 'searchText':
+            if search_text is None:
+                raise ValueError('a union value must not be None')
+            self._search_text = search_text
+            self._type = 'searchText'
+        elif type_of_union == 'label':
+            if label is None:
+                raise ValueError('a union value must not be None')
+            self._label = label
+            self._type = 'label'
+        elif type_of_union == 'property':
+            if property is None:
+                raise ValueError('a union value must not be None')
+            self._property = property
+            self._type = 'property'
+        elif type_of_union == 'and':
+            if and_ is None:
+                raise ValueError('a union value must not be None')
+            self._and_ = and_
+            self._type = 'and'
+        elif type_of_union == 'or':
+            if or_ is None:
+                raise ValueError('a union value must not be None')
+            self._or_ = or_
+            self._type = 'or'
+        elif type_of_union == 'workspace':
+            if workspace is None:
+                raise ValueError('a union value must not be None')
+            self._workspace = workspace
+            self._type = 'workspace'
+
+    @builtins.property
+    def search_text(self) -> Optional[str]:
+        return self._search_text
+
+    @builtins.property
+    def label(self) -> Optional[str]:
+        return self._label
+
+    @builtins.property
+    def property(self) -> Optional["api_Property"]:
+        return self._property
+
+    @builtins.property
+    def and_(self) -> Optional[List["ingest_api_SearchContainerizedExtractorsQuery"]]:
+        return self._and_
+
+    @builtins.property
+    def or_(self) -> Optional[List["ingest_api_SearchContainerizedExtractorsQuery"]]:
+        return self._or_
+
+    @builtins.property
+    def workspace(self) -> Optional[str]:
+        return self._workspace
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, ingest_api_SearchContainerizedExtractorsQueryVisitor):
+            raise ValueError('{} is not an instance of ingest_api_SearchContainerizedExtractorsQueryVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'searchText' and self.search_text is not None:
+            return visitor._search_text(self.search_text)
+        if self._type == 'label' and self.label is not None:
+            return visitor._label(self.label)
+        if self._type == 'property' and self.property is not None:
+            return visitor._property(self.property)
+        if self._type == 'and' and self.and_ is not None:
+            return visitor._and(self.and_)
+        if self._type == 'or' and self.or_ is not None:
+            return visitor._or(self.or_)
+        if self._type == 'workspace' and self.workspace is not None:
+            return visitor._workspace(self.workspace)
+
+
+ingest_api_SearchContainerizedExtractorsQuery.__name__ = "SearchContainerizedExtractorsQuery"
+ingest_api_SearchContainerizedExtractorsQuery.__qualname__ = "SearchContainerizedExtractorsQuery"
+ingest_api_SearchContainerizedExtractorsQuery.__module__ = "nominal_api.ingest_api"
+
+
+class ingest_api_SearchContainerizedExtractorsQueryVisitor:
+
+    @abstractmethod
+    def _search_text(self, search_text: str) -> Any:
+        pass
+
+    @abstractmethod
+    def _label(self, label: str) -> Any:
+        pass
+
+    @abstractmethod
+    def _property(self, property: "api_Property") -> Any:
+        pass
+
+    @abstractmethod
+    def _and(self, and_: List["ingest_api_SearchContainerizedExtractorsQuery"]) -> Any:
+        pass
+
+    @abstractmethod
+    def _or(self, or_: List["ingest_api_SearchContainerizedExtractorsQuery"]) -> Any:
+        pass
+
+    @abstractmethod
+    def _workspace(self, workspace: str) -> Any:
+        pass
+
+
+ingest_api_SearchContainerizedExtractorsQueryVisitor.__name__ = "SearchContainerizedExtractorsQueryVisitor"
+ingest_api_SearchContainerizedExtractorsQueryVisitor.__qualname__ = "SearchContainerizedExtractorsQueryVisitor"
+ingest_api_SearchContainerizedExtractorsQueryVisitor.__module__ = "nominal_api.ingest_api"
+
+
+class ingest_api_SearchContainerizedExtractorsRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'query': ConjureFieldDefinition('query', ingest_api_SearchContainerizedExtractorsQuery)
+        }
+
+    __slots__: List[str] = ['_query']
+
+    def __init__(self, query: "ingest_api_SearchContainerizedExtractorsQuery") -> None:
+        self._query = query
+
+    @builtins.property
+    def query(self) -> "ingest_api_SearchContainerizedExtractorsQuery":
+        return self._query
+
+
+ingest_api_SearchContainerizedExtractorsRequest.__name__ = "SearchContainerizedExtractorsRequest"
+ingest_api_SearchContainerizedExtractorsRequest.__qualname__ = "SearchContainerizedExtractorsRequest"
+ingest_api_SearchContainerizedExtractorsRequest.__module__ = "nominal_api.ingest_api"
+
+
 class ingest_api_SignPartResponse(ConjureBeanType):
 
     @builtins.classmethod
@@ -10026,6 +10816,85 @@ ingest_api_TriggeredIngest.__qualname__ = "TriggeredIngest"
 ingest_api_TriggeredIngest.__module__ = "nominal_api.ingest_api"
 
 
+class ingest_api_UpdateContainerizedExtractorRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'name': ConjureFieldDefinition('name', OptionalTypeWrapper[str]),
+            'description': ConjureFieldDefinition('description', OptionalTypeWrapper[str]),
+            'properties': ConjureFieldDefinition('properties', OptionalTypeWrapper[Dict[api_PropertyName, api_PropertyValue]]),
+            'labels': ConjureFieldDefinition('labels', OptionalTypeWrapper[List[api_Label]])
+        }
+
+    __slots__: List[str] = ['_name', '_description', '_properties', '_labels']
+
+    def __init__(self, description: Optional[str] = None, labels: Optional[List[str]] = None, name: Optional[str] = None, properties: Optional[Dict[str, str]] = None) -> None:
+        self._name = name
+        self._description = description
+        self._properties = properties
+        self._labels = labels
+
+    @builtins.property
+    def name(self) -> Optional[str]:
+        return self._name
+
+    @builtins.property
+    def description(self) -> Optional[str]:
+        return self._description
+
+    @builtins.property
+    def properties(self) -> Optional[Dict[str, str]]:
+        return self._properties
+
+    @builtins.property
+    def labels(self) -> Optional[List[str]]:
+        return self._labels
+
+
+ingest_api_UpdateContainerizedExtractorRequest.__name__ = "UpdateContainerizedExtractorRequest"
+ingest_api_UpdateContainerizedExtractorRequest.__qualname__ = "UpdateContainerizedExtractorRequest"
+ingest_api_UpdateContainerizedExtractorRequest.__module__ = "nominal_api.ingest_api"
+
+
+class ingest_api_UserAndPasswordAuthentication(ConjureBeanType):
+    """
+    Username and password authentication.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'username': ConjureFieldDefinition('username', str),
+            'password_secret_rid': ConjureFieldDefinition('passwordSecretRid', secrets_api_SecretRid)
+        }
+
+    __slots__: List[str] = ['_username', '_password_secret_rid']
+
+    def __init__(self, password_secret_rid: str, username: str) -> None:
+        self._username = username
+        self._password_secret_rid = password_secret_rid
+
+    @builtins.property
+    def username(self) -> str:
+        """
+        Username for registry authentication.
+        """
+        return self._username
+
+    @builtins.property
+    def password_secret_rid(self) -> str:
+        """
+        The RID of the secret containing the password for registry authentication.
+        """
+        return self._password_secret_rid
+
+
+ingest_api_UserAndPasswordAuthentication.__name__ = "UserAndPasswordAuthentication"
+ingest_api_UserAndPasswordAuthentication.__qualname__ = "UserAndPasswordAuthentication"
+ingest_api_UserAndPasswordAuthentication.__module__ = "nominal_api.ingest_api"
+
+
 class ingest_api_UtcTimestamp(ConjureBeanType):
 
     @builtins.classmethod
@@ -11879,6 +12748,35 @@ includes metrics for check and violation review status.
         _decoder = ConjureDecoder()
         return _decoder.decode(_response.json(), bool, self._return_none_for_unknown_union_types)
 
+    def unarchive_run(self, auth_header: str, rid: str) -> bool:
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+            'rid': rid,
+        }
+
+        _json: Any = None
+
+        _path = '/scout/v1/unarchive-run/{rid}'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'PUT',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        _decoder = ConjureDecoder()
+        return _decoder.decode(_response.json(), bool, self._return_none_for_unknown_union_types)
+
     def get_data_source_ref_name_and_type_list(self, auth_header: str, workspaces: List[str] = None) -> List["scout_run_api_RefNameAndType"]:
         """
         Returns the list of ref names that are in use across specified and authorized workspaces.
@@ -12361,6 +13259,40 @@ default, follow the UCUM convention for representation.
         _decoder = ConjureDecoder()
         return None if _response.status_code == 204 else _decoder.decode(_response.json(), OptionalTypeWrapper[scout_units_api_Unit], self._return_none_for_unknown_union_types)
 
+    def get_batch_units(self, auth_header: str, units: List[str] = None) -> Dict[str, "scout_units_api_Unit"]:
+        """
+        Returns information for the unit symbols if available. If the provided symbol cannot be parsed, it will be 
+omitted from the map.
+        """
+        units = units if units is not None else []
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+        }
+
+        _json: Any = ConjureEncoder().default(units)
+
+        _path = '/units/v1/units/get-batch-units'
+        _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(), Dict[scout_units_api_UnitSymbol, scout_units_api_Unit], self._return_none_for_unknown_union_types)
+
     def get_commensurable_units(self, auth_header: str, unit: str) -> List["scout_units_api_Unit"]:
         """
         Returns the set of cataloged units that can be converted to and from the given unit.
@@ -13107,12 +14039,13 @@ class scout_asset_api_Asset(ConjureBeanType):
             'updated_at': ConjureFieldDefinition('updatedAt', str),
             'attachments': ConjureFieldDefinition('attachments', List[api_rids_AttachmentRid]),
             'type': ConjureFieldDefinition('type', OptionalTypeWrapper[scout_rids_api_TypeRid]),
-            'is_staged': ConjureFieldDefinition('isStaged', bool)
+            'is_staged': ConjureFieldDefinition('isStaged', bool),
+            'is_archived': ConjureFieldDefinition('isArchived', bool)
         }
 
-    __slots__: List[str] = ['_rid', '_title', '_description', '_properties', '_labels', '_links', '_data_scopes', '_created_by', '_created_at', '_updated_at', '_attachments', '_type', '_is_staged']
+    __slots__: List[str] = ['_rid', '_title', '_description', '_properties', '_labels', '_links', '_data_scopes', '_created_by', '_created_at', '_updated_at', '_attachments', '_type', '_is_staged', '_is_archived']
 
-    def __init__(self, attachments: List[str], created_at: str, data_scopes: List["scout_asset_api_AssetDataScope"], is_staged: bool, labels: List[str], links: List["scout_run_api_Link"], properties: Dict[str, str], rid: str, title: str, updated_at: str, created_by: Optional[str] = None, description: Optional[str] = None, type: Optional[str] = None) -> None:
+    def __init__(self, attachments: List[str], created_at: str, data_scopes: List["scout_asset_api_AssetDataScope"], is_archived: bool, is_staged: bool, labels: List[str], links: List["scout_run_api_Link"], properties: Dict[str, str], rid: str, title: str, updated_at: str, created_by: Optional[str] = None, description: Optional[str] = None, type: Optional[str] = None) -> None:
         self._rid = rid
         self._title = title
         self._description = description
@@ -13126,6 +14059,7 @@ class scout_asset_api_Asset(ConjureBeanType):
         self._attachments = attachments
         self._type = type
         self._is_staged = is_staged
+        self._is_archived = is_archived
 
     @builtins.property
     def rid(self) -> str:
@@ -13193,6 +14127,10 @@ To associate links with a range of time, create a time range on the asset with l
         """
         return self._is_staged
 
+    @builtins.property
+    def is_archived(self) -> bool:
+        return self._is_archived
+
 
 scout_asset_api_Asset.__name__ = "Asset"
 scout_asset_api_Asset.__qualname__ = "Asset"
@@ -15387,35 +16325,6 @@ a file, primarily CSV.
         _decoder = ConjureDecoder()
         return None if _response.status_code == 204 else _decoder.decode(_response.json(), OptionalTypeWrapper[scout_catalog_Handle], self._return_none_for_unknown_union_types)
 
-    def get_series_details(self, auth_header: str, get_series_details: "scout_catalog_GetSeriesDetailsRequest") -> "scout_catalog_SeriesDetails":
-
-        _headers: Dict[str, Any] = {
-            'Accept': 'application/json',
-            'Content-Type': 'application/json',
-            'Authorization': auth_header,
-        }
-
-        _params: Dict[str, Any] = {
-        }
-
-        _path_params: Dict[str, Any] = {
-        }
-
-        _json: Any = ConjureEncoder().default(get_series_details)
-
-        _path = '/catalog/v1/series/details'
-        _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(), scout_catalog_SeriesDetails, self._return_none_for_unknown_union_types)
-
     def create_dataset(self, auth_header: str, details: "scout_catalog_CreateDataset") -> "scout_catalog_EnrichedDataset":
 
         _headers: Dict[str, Any] = {
@@ -15727,35 +16636,6 @@ the bounds will be min(current start, request start), max(current end, request e
         _decoder = ConjureDecoder()
         return _decoder.decode(_response.json(), scout_catalog_Dataset, self._return_none_for_unknown_union_types)
 
-    def delete_dataset_series(self, auth_header: str, dataset_rid: str) -> "scout_catalog_DeleteSeriesResult":
-
-        _headers: Dict[str, Any] = {
-            'Accept': 'application/json',
-            'Authorization': auth_header,
-        }
-
-        _params: Dict[str, Any] = {
-        }
-
-        _path_params: Dict[str, Any] = {
-            'datasetRid': dataset_rid,
-        }
-
-        _json: Any = None
-
-        _path = '/catalog/v1/series/for-dataset/{datasetRid}'
-        _path = _path.format(**_path_params)
-
-        _response: Response = self._request(
-            'DELETE',
-            self._uri + _path,
-            params=_params,
-            headers=_headers,
-            json=_json)
-
-        _decoder = ConjureDecoder()
-        return _decoder.decode(_response.json(), scout_catalog_DeleteSeriesResult, self._return_none_for_unknown_union_types)
-
     def archive_dataset(self, auth_header: str, dataset_rid: str) -> None:
         """
         Archives a dataset, which will hide it from search results unless the includeArchived flag is set to true. The
@@ -16423,29 +17303,6 @@ scout_catalog_DatasetOriginMetadata.__qualname__ = "DatasetOriginMetadata"
 scout_catalog_DatasetOriginMetadata.__module__ = "nominal_api.scout_catalog"
 
 
-class scout_catalog_DeleteSeriesResult(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'number_deleted': ConjureFieldDefinition('numberDeleted', int)
-        }
-
-    __slots__: List[str] = ['_number_deleted']
-
-    def __init__(self, number_deleted: int) -> None:
-        self._number_deleted = number_deleted
-
-    @builtins.property
-    def number_deleted(self) -> int:
-        return self._number_deleted
-
-
-scout_catalog_DeleteSeriesResult.__name__ = "DeleteSeriesResult"
-scout_catalog_DeleteSeriesResult.__qualname__ = "DeleteSeriesResult"
-scout_catalog_DeleteSeriesResult.__module__ = "nominal_api.scout_catalog"
-
-
 class scout_catalog_EnrichedDataset(ConjureBeanType):
 
     @builtins.classmethod
@@ -16692,135 +17549,6 @@ scout_catalog_GetHandlesForDatasetsRequest.__qualname__ = "GetHandlesForDatasets
 scout_catalog_GetHandlesForDatasetsRequest.__module__ = "nominal_api.scout_catalog"
 
 
-class scout_catalog_GetSeriesDetailsByName(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'dataset_rid': ConjureFieldDefinition('datasetRid', str),
-            'name': ConjureFieldDefinition('name', str)
-        }
-
-    __slots__: List[str] = ['_dataset_rid', '_name']
-
-    def __init__(self, dataset_rid: str, name: str) -> None:
-        self._dataset_rid = dataset_rid
-        self._name = name
-
-    @builtins.property
-    def dataset_rid(self) -> str:
-        return self._dataset_rid
-
-    @builtins.property
-    def name(self) -> str:
-        return self._name
-
-
-scout_catalog_GetSeriesDetailsByName.__name__ = "GetSeriesDetailsByName"
-scout_catalog_GetSeriesDetailsByName.__qualname__ = "GetSeriesDetailsByName"
-scout_catalog_GetSeriesDetailsByName.__module__ = "nominal_api.scout_catalog"
-
-
-class scout_catalog_GetSeriesDetailsByRid(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'rid': ConjureFieldDefinition('rid', str)
-        }
-
-    __slots__: List[str] = ['_rid']
-
-    def __init__(self, rid: str) -> None:
-        self._rid = rid
-
-    @builtins.property
-    def rid(self) -> str:
-        return self._rid
-
-
-scout_catalog_GetSeriesDetailsByRid.__name__ = "GetSeriesDetailsByRid"
-scout_catalog_GetSeriesDetailsByRid.__qualname__ = "GetSeriesDetailsByRid"
-scout_catalog_GetSeriesDetailsByRid.__module__ = "nominal_api.scout_catalog"
-
-
-class scout_catalog_GetSeriesDetailsRequest(ConjureUnionType):
-    _by_rid: Optional["scout_catalog_GetSeriesDetailsByRid"] = None
-    _by_name: Optional["scout_catalog_GetSeriesDetailsByName"] = None
-
-    @builtins.classmethod
-    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'by_rid': ConjureFieldDefinition('byRid', scout_catalog_GetSeriesDetailsByRid),
-            'by_name': ConjureFieldDefinition('byName', scout_catalog_GetSeriesDetailsByName)
-        }
-
-    def __init__(
-            self,
-            by_rid: Optional["scout_catalog_GetSeriesDetailsByRid"] = None,
-            by_name: Optional["scout_catalog_GetSeriesDetailsByName"] = None,
-            type_of_union: Optional[str] = None
-            ) -> None:
-        if type_of_union is None:
-            if (by_rid is not None) + (by_name is not None) != 1:
-                raise ValueError('a union must contain a single member')
-
-            if by_rid is not None:
-                self._by_rid = by_rid
-                self._type = 'byRid'
-            if by_name is not None:
-                self._by_name = by_name
-                self._type = 'byName'
-
-        elif type_of_union == 'byRid':
-            if by_rid is None:
-                raise ValueError('a union value must not be None')
-            self._by_rid = by_rid
-            self._type = 'byRid'
-        elif type_of_union == 'byName':
-            if by_name is None:
-                raise ValueError('a union value must not be None')
-            self._by_name = by_name
-            self._type = 'byName'
-
-    @builtins.property
-    def by_rid(self) -> Optional["scout_catalog_GetSeriesDetailsByRid"]:
-        return self._by_rid
-
-    @builtins.property
-    def by_name(self) -> Optional["scout_catalog_GetSeriesDetailsByName"]:
-        return self._by_name
-
-    def accept(self, visitor) -> Any:
-        if not isinstance(visitor, scout_catalog_GetSeriesDetailsRequestVisitor):
-            raise ValueError('{} is not an instance of scout_catalog_GetSeriesDetailsRequestVisitor'.format(visitor.__class__.__name__))
-        if self._type == 'byRid' and self.by_rid is not None:
-            return visitor._by_rid(self.by_rid)
-        if self._type == 'byName' and self.by_name is not None:
-            return visitor._by_name(self.by_name)
-
-
-scout_catalog_GetSeriesDetailsRequest.__name__ = "GetSeriesDetailsRequest"
-scout_catalog_GetSeriesDetailsRequest.__qualname__ = "GetSeriesDetailsRequest"
-scout_catalog_GetSeriesDetailsRequest.__module__ = "nominal_api.scout_catalog"
-
-
-class scout_catalog_GetSeriesDetailsRequestVisitor:
-
-    @abstractmethod
-    def _by_rid(self, by_rid: "scout_catalog_GetSeriesDetailsByRid") -> Any:
-        pass
-
-    @abstractmethod
-    def _by_name(self, by_name: "scout_catalog_GetSeriesDetailsByName") -> Any:
-        pass
-
-
-scout_catalog_GetSeriesDetailsRequestVisitor.__name__ = "GetSeriesDetailsRequestVisitor"
-scout_catalog_GetSeriesDetailsRequestVisitor.__qualname__ = "GetSeriesDetailsRequestVisitor"
-scout_catalog_GetSeriesDetailsRequestVisitor.__module__ = "nominal_api.scout_catalog"
-
-
 class scout_catalog_Handle(ConjureUnionType):
     _s3: Optional["scout_catalog_S3Handle"] = None
 
@@ -17582,59 +18310,6 @@ scout_catalog_SearchDatasetsResponse.__qualname__ = "SearchDatasetsResponse"
 scout_catalog_SearchDatasetsResponse.__module__ = "nominal_api.scout_catalog"
 
 
-class scout_catalog_SeriesDetails(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'rid': ConjureFieldDefinition('rid', str),
-            'name': ConjureFieldDefinition('name', str),
-            'origin_metadata': ConjureFieldDefinition('originMetadata', Dict[str, str]),
-            'csv_index': ConjureFieldDefinition('csvIndex', OptionalTypeWrapper[int]),
-            'dataset_rid': ConjureFieldDefinition('datasetRid', str),
-            'handle': ConjureFieldDefinition('handle', scout_catalog_Handle)
-        }
-
-    __slots__: List[str] = ['_rid', '_name', '_origin_metadata', '_csv_index', '_dataset_rid', '_handle']
-
-    def __init__(self, dataset_rid: str, handle: "scout_catalog_Handle", name: str, origin_metadata: Dict[str, str], rid: str, csv_index: Optional[int] = None) -> None:
-        self._rid = rid
-        self._name = name
-        self._origin_metadata = origin_metadata
-        self._csv_index = csv_index
-        self._dataset_rid = dataset_rid
-        self._handle = handle
-
-    @builtins.property
-    def rid(self) -> str:
-        return self._rid
-
-    @builtins.property
-    def name(self) -> str:
-        return self._name
-
-    @builtins.property
-    def origin_metadata(self) -> Dict[str, str]:
-        return self._origin_metadata
-
-    @builtins.property
-    def csv_index(self) -> Optional[int]:
-        return self._csv_index
-
-    @builtins.property
-    def dataset_rid(self) -> str:
-        return self._dataset_rid
-
-    @builtins.property
-    def handle(self) -> "scout_catalog_Handle":
-        return self._handle
-
-
-scout_catalog_SeriesDetails.__name__ = "SeriesDetails"
-scout_catalog_SeriesDetails.__qualname__ = "SeriesDetails"
-scout_catalog_SeriesDetails.__module__ = "nominal_api.scout_catalog"
-
-
 class scout_catalog_SkipRowsConfig(ConjureBeanType):
 
     @builtins.classmethod
@@ -44441,6 +45116,35 @@ scout_compute_resolved_api_BitOperationSeriesNode.__qualname__ = "BitOperationSe
 scout_compute_resolved_api_BitOperationSeriesNode.__module__ = "nominal_api.scout_compute_resolved_api"
 
 
+class scout_compute_resolved_api_CachedStorageLocator(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'series_uuids': ConjureFieldDefinition('seriesUuids', List[str]),
+            'type': ConjureFieldDefinition('type', storage_series_api_NominalDataType)
+        }
+
+    __slots__: List[str] = ['_series_uuids', '_type']
+
+    def __init__(self, series_uuids: List[str], type: "storage_series_api_NominalDataType") -> None:
+        self._series_uuids = series_uuids
+        self._type = type
+
+    @builtins.property
+    def series_uuids(self) -> List[str]:
+        return self._series_uuids
+
+    @builtins.property
+    def type(self) -> "storage_series_api_NominalDataType":
+        return self._type
+
+
+scout_compute_resolved_api_CachedStorageLocator.__name__ = "CachedStorageLocator"
+scout_compute_resolved_api_CachedStorageLocator.__qualname__ = "CachedStorageLocator"
+scout_compute_resolved_api_CachedStorageLocator.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
 class scout_compute_resolved_api_Cartesian3dBounds(ConjureBeanType):
 
     @builtins.classmethod
@@ -44650,6 +45354,41 @@ scout_compute_resolved_api_CartesianNodeVisitor.__qualname__ = "CartesianNodeVis
 scout_compute_resolved_api_CartesianNodeVisitor.__module__ = "nominal_api.scout_compute_resolved_api"
 
 
+class scout_compute_resolved_api_ClickHouseSeriesResolutionDetails(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'channel': ConjureFieldDefinition('channel', api_Channel),
+            'tags': ConjureFieldDefinition('tags', Dict[api_TagName, api_TagValue]),
+            'org_rid': ConjureFieldDefinition('orgRid', authentication_api_OrgRid)
+        }
+
+    __slots__: List[str] = ['_channel', '_tags', '_org_rid']
+
+    def __init__(self, channel: str, org_rid: str, tags: Dict[str, str]) -> None:
+        self._channel = channel
+        self._tags = tags
+        self._org_rid = org_rid
+
+    @builtins.property
+    def channel(self) -> str:
+        return self._channel
+
+    @builtins.property
+    def tags(self) -> Dict[str, str]:
+        return self._tags
+
+    @builtins.property
+    def org_rid(self) -> str:
+        return self._org_rid
+
+
+scout_compute_resolved_api_ClickHouseSeriesResolutionDetails.__name__ = "ClickHouseSeriesResolutionDetails"
+scout_compute_resolved_api_ClickHouseSeriesResolutionDetails.__qualname__ = "ClickHouseSeriesResolutionDetails"
+scout_compute_resolved_api_ClickHouseSeriesResolutionDetails.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
 class scout_compute_resolved_api_CumulativeSumSeriesNode(ConjureBeanType):
 
     @builtins.classmethod
@@ -46107,6 +46846,47 @@ scout_compute_resolved_api_MinSeriesNode.__qualname__ = "MinSeriesNode"
 scout_compute_resolved_api_MinSeriesNode.__module__ = "nominal_api.scout_compute_resolved_api"
 
 
+class scout_compute_resolved_api_NominalStorageLocator(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'data_source_rid': ConjureFieldDefinition('dataSourceRid', api_rids_NominalDataSourceOrDatasetRid),
+            'type': ConjureFieldDefinition('type', storage_series_api_NominalDataType),
+            'details': ConjureFieldDefinition('details', scout_compute_resolved_api_ClickHouseSeriesResolutionDetails),
+            'is_in_memory_streaming_enabled': ConjureFieldDefinition('isInMemoryStreamingEnabled', bool)
+        }
+
+    __slots__: List[str] = ['_data_source_rid', '_type', '_details', '_is_in_memory_streaming_enabled']
+
+    def __init__(self, data_source_rid: str, details: "scout_compute_resolved_api_ClickHouseSeriesResolutionDetails", is_in_memory_streaming_enabled: bool, type: "storage_series_api_NominalDataType") -> None:
+        self._data_source_rid = data_source_rid
+        self._type = type
+        self._details = details
+        self._is_in_memory_streaming_enabled = is_in_memory_streaming_enabled
+
+    @builtins.property
+    def data_source_rid(self) -> str:
+        return self._data_source_rid
+
+    @builtins.property
+    def type(self) -> "storage_series_api_NominalDataType":
+        return self._type
+
+    @builtins.property
+    def details(self) -> "scout_compute_resolved_api_ClickHouseSeriesResolutionDetails":
+        return self._details
+
+    @builtins.property
+    def is_in_memory_streaming_enabled(self) -> bool:
+        return self._is_in_memory_streaming_enabled
+
+
+scout_compute_resolved_api_NominalStorageLocator.__name__ = "NominalStorageLocator"
+scout_compute_resolved_api_NominalStorageLocator.__qualname__ = "NominalStorageLocator"
+scout_compute_resolved_api_NominalStorageLocator.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
 class scout_compute_resolved_api_NotRangesNode(ConjureBeanType):
 
     @builtins.classmethod
@@ -47508,16 +48288,16 @@ class scout_compute_resolved_api_RawEnumSeriesNode(ConjureBeanType):
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'series': ConjureFieldDefinition('series', scout_compute_api_SeriesSpec)
+            'series': ConjureFieldDefinition('series', scout_compute_resolved_api_ResolvedSeries)
         }
 
     __slots__: List[str] = ['_series']
 
-    def __init__(self, series: "scout_compute_api_SeriesSpec") -> None:
+    def __init__(self, series: "scout_compute_resolved_api_ResolvedSeries") -> None:
         self._series = series
 
     @builtins.property
-    def series(self) -> "scout_compute_api_SeriesSpec":
+    def series(self) -> "scout_compute_resolved_api_ResolvedSeries":
         return self._series
 
 
@@ -47531,16 +48311,16 @@ class scout_compute_resolved_api_RawLogSeriesNode(ConjureBeanType):
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'series': ConjureFieldDefinition('series', scout_compute_api_SeriesSpec)
+            'series': ConjureFieldDefinition('series', scout_compute_resolved_api_ResolvedSeries)
         }
 
     __slots__: List[str] = ['_series']
 
-    def __init__(self, series: "scout_compute_api_SeriesSpec") -> None:
+    def __init__(self, series: "scout_compute_resolved_api_ResolvedSeries") -> None:
         self._series = series
 
     @builtins.property
-    def series(self) -> "scout_compute_api_SeriesSpec":
+    def series(self) -> "scout_compute_resolved_api_ResolvedSeries":
         return self._series
 
 
@@ -47554,16 +48334,16 @@ class scout_compute_resolved_api_RawNumericSeriesNode(ConjureBeanType):
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'series': ConjureFieldDefinition('series', scout_compute_api_SeriesSpec)
+            'series': ConjureFieldDefinition('series', scout_compute_resolved_api_ResolvedSeries)
         }
 
     __slots__: List[str] = ['_series']
 
-    def __init__(self, series: "scout_compute_api_SeriesSpec") -> None:
+    def __init__(self, series: "scout_compute_resolved_api_ResolvedSeries") -> None:
         self._series = series
 
     @builtins.property
-    def series(self) -> "scout_compute_api_SeriesSpec":
+    def series(self) -> "scout_compute_resolved_api_ResolvedSeries":
         return self._series
 
 
@@ -47577,16 +48357,16 @@ class scout_compute_resolved_api_RawUntypedSeriesNode(ConjureBeanType):
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'series': ConjureFieldDefinition('series', scout_compute_api_SeriesSpec)
+            'series': ConjureFieldDefinition('series', scout_compute_resolved_api_ResolvedSeries)
         }
 
     __slots__: List[str] = ['_series']
 
-    def __init__(self, series: "scout_compute_api_SeriesSpec") -> None:
+    def __init__(self, series: "scout_compute_resolved_api_ResolvedSeries") -> None:
         self._series = series
 
     @builtins.property
-    def series(self) -> "scout_compute_api_SeriesSpec":
+    def series(self) -> "scout_compute_resolved_api_ResolvedSeries":
         return self._series
 
 
@@ -47883,6 +48663,47 @@ scout_compute_resolved_api_ResolvedNodeVisitor.__qualname__ = "ResolvedNodeVisit
 scout_compute_resolved_api_ResolvedNodeVisitor.__module__ = "nominal_api.scout_compute_resolved_api"
 
 
+class scout_compute_resolved_api_ResolvedSeries(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'logical_series': ConjureFieldDefinition('logicalSeries', timeseries_logicalseries_api_LogicalSeries),
+            'series_spec': ConjureFieldDefinition('seriesSpec', scout_compute_api_SeriesSpec),
+            'storage_locator': ConjureFieldDefinition('storageLocator', OptionalTypeWrapper[scout_compute_resolved_api_StorageLocator]),
+            'granularity': ConjureFieldDefinition('granularity', api_Granularity)
+        }
+
+    __slots__: List[str] = ['_logical_series', '_series_spec', '_storage_locator', '_granularity']
+
+    def __init__(self, granularity: "api_Granularity", logical_series: "timeseries_logicalseries_api_LogicalSeries", series_spec: "scout_compute_api_SeriesSpec", storage_locator: Optional["scout_compute_resolved_api_StorageLocator"] = None) -> None:
+        self._logical_series = logical_series
+        self._series_spec = series_spec
+        self._storage_locator = storage_locator
+        self._granularity = granularity
+
+    @builtins.property
+    def logical_series(self) -> "timeseries_logicalseries_api_LogicalSeries":
+        return self._logical_series
+
+    @builtins.property
+    def series_spec(self) -> "scout_compute_api_SeriesSpec":
+        return self._series_spec
+
+    @builtins.property
+    def storage_locator(self) -> Optional["scout_compute_resolved_api_StorageLocator"]:
+        return self._storage_locator
+
+    @builtins.property
+    def granularity(self) -> "api_Granularity":
+        return self._granularity
+
+
+scout_compute_resolved_api_ResolvedSeries.__name__ = "ResolvedSeries"
+scout_compute_resolved_api_ResolvedSeries.__qualname__ = "ResolvedSeries"
+scout_compute_resolved_api_ResolvedSeries.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
 class scout_compute_resolved_api_RollingOperationSeriesNode(ConjureBeanType):
 
     @builtins.classmethod
@@ -48514,6 +49335,83 @@ scout_compute_resolved_api_StaleRangesNode.__qualname__ = "StaleRangesNode"
 scout_compute_resolved_api_StaleRangesNode.__module__ = "nominal_api.scout_compute_resolved_api"
 
 
+class scout_compute_resolved_api_StorageLocator(ConjureUnionType):
+    _cached: Optional["scout_compute_resolved_api_CachedStorageLocator"] = None
+    _nominal: Optional["scout_compute_resolved_api_NominalStorageLocator"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'cached': ConjureFieldDefinition('cached', scout_compute_resolved_api_CachedStorageLocator),
+            'nominal': ConjureFieldDefinition('nominal', scout_compute_resolved_api_NominalStorageLocator)
+        }
+
+    def __init__(
+            self,
+            cached: Optional["scout_compute_resolved_api_CachedStorageLocator"] = None,
+            nominal: Optional["scout_compute_resolved_api_NominalStorageLocator"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (cached is not None) + (nominal is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if cached is not None:
+                self._cached = cached
+                self._type = 'cached'
+            if nominal is not None:
+                self._nominal = nominal
+                self._type = 'nominal'
+
+        elif type_of_union == 'cached':
+            if cached is None:
+                raise ValueError('a union value must not be None')
+            self._cached = cached
+            self._type = 'cached'
+        elif type_of_union == 'nominal':
+            if nominal is None:
+                raise ValueError('a union value must not be None')
+            self._nominal = nominal
+            self._type = 'nominal'
+
+    @builtins.property
+    def cached(self) -> Optional["scout_compute_resolved_api_CachedStorageLocator"]:
+        return self._cached
+
+    @builtins.property
+    def nominal(self) -> Optional["scout_compute_resolved_api_NominalStorageLocator"]:
+        return self._nominal
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_compute_resolved_api_StorageLocatorVisitor):
+            raise ValueError('{} is not an instance of scout_compute_resolved_api_StorageLocatorVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'cached' and self.cached is not None:
+            return visitor._cached(self.cached)
+        if self._type == 'nominal' and self.nominal is not None:
+            return visitor._nominal(self.nominal)
+
+
+scout_compute_resolved_api_StorageLocator.__name__ = "StorageLocator"
+scout_compute_resolved_api_StorageLocator.__qualname__ = "StorageLocator"
+scout_compute_resolved_api_StorageLocator.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
+class scout_compute_resolved_api_StorageLocatorVisitor:
+
+    @abstractmethod
+    def _cached(self, cached: "scout_compute_resolved_api_CachedStorageLocator") -> Any:
+        pass
+
+    @abstractmethod
+    def _nominal(self, nominal: "scout_compute_resolved_api_NominalStorageLocator") -> Any:
+        pass
+
+
+scout_compute_resolved_api_StorageLocatorVisitor.__name__ = "StorageLocatorVisitor"
+scout_compute_resolved_api_StorageLocatorVisitor.__qualname__ = "StorageLocatorVisitor"
+scout_compute_resolved_api_StorageLocatorVisitor.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
 class scout_compute_resolved_api_SumSeriesNode(ConjureBeanType):
 
     @builtins.classmethod
@@ -61999,12 +62897,13 @@ class scout_run_api_Run(ConjureBeanType):
             'data_sources': ConjureFieldDefinition('dataSources', Dict[scout_api_DataSourceRefName, scout_run_api_RunDataSource]),
             'attachments': ConjureFieldDefinition('attachments', List[api_rids_AttachmentRid]),
             'asset': ConjureFieldDefinition('asset', OptionalTypeWrapper[scout_rids_api_AssetRid]),
-            'assets': ConjureFieldDefinition('assets', List[scout_rids_api_AssetRid])
+            'assets': ConjureFieldDefinition('assets', List[scout_rids_api_AssetRid]),
+            'is_archived': ConjureFieldDefinition('isArchived', bool)
         }
 
-    __slots__: List[str] = ['_rid', '_run_number', '_run_prefix', '_title', '_description', '_author_rid', '_start_time', '_end_time', '_properties', '_labels', '_links', '_created_at', '_updated_at', '_asset_data_scopes', '_data_sources', '_attachments', '_asset', '_assets']
+    __slots__: List[str] = ['_rid', '_run_number', '_run_prefix', '_title', '_description', '_author_rid', '_start_time', '_end_time', '_properties', '_labels', '_links', '_created_at', '_updated_at', '_asset_data_scopes', '_data_sources', '_attachments', '_asset', '_assets', '_is_archived']
 
-    def __init__(self, asset_data_scopes: List["scout_asset_api_AssetDataScope"], assets: List[str], attachments: List[str], created_at: str, data_sources: Dict[str, "scout_run_api_RunDataSource"], description: str, labels: List[str], links: List["scout_run_api_Link"], properties: Dict[str, str], rid: str, run_number: int, start_time: "scout_run_api_UtcTimestamp", title: str, updated_at: str, asset: Optional[str] = None, author_rid: Optional[str] = None, end_time: Optional["scout_run_api_UtcTimestamp"] = None, run_prefix: Optional[str] = None) -> None:
+    def __init__(self, asset_data_scopes: List["scout_asset_api_AssetDataScope"], assets: List[str], attachments: List[str], created_at: str, data_sources: Dict[str, "scout_run_api_RunDataSource"], description: str, is_archived: bool, labels: List[str], links: List["scout_run_api_Link"], properties: Dict[str, str], rid: str, run_number: int, start_time: "scout_run_api_UtcTimestamp", title: str, updated_at: str, asset: Optional[str] = None, author_rid: Optional[str] = None, end_time: Optional["scout_run_api_UtcTimestamp"] = None, run_prefix: Optional[str] = None) -> None:
         self._rid = rid
         self._run_number = run_number
         self._run_prefix = run_prefix
@@ -62023,6 +62922,7 @@ class scout_run_api_Run(ConjureBeanType):
         self._attachments = attachments
         self._asset = asset
         self._assets = assets
+        self._is_archived = is_archived
 
     @builtins.property
     def rid(self) -> str:
@@ -62099,6 +62999,10 @@ class scout_run_api_Run(ConjureBeanType):
     def assets(self) -> List[str]:
         return self._assets
 
+    @builtins.property
+    def is_archived(self) -> bool:
+        return self._is_archived
+
 
 scout_run_api_Run.__name__ = "Run"
 scout_run_api_Run.__qualname__ = "Run"
@@ -62767,16 +63671,18 @@ class scout_run_api_SearchRunsRequest(ConjureBeanType):
             'sort': ConjureFieldDefinition('sort', scout_run_api_SortOptions),
             'page_size': ConjureFieldDefinition('pageSize', int),
             'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token]),
-            'query': ConjureFieldDefinition('query', scout_run_api_SearchQuery)
+            'query': ConjureFieldDefinition('query', scout_run_api_SearchQuery),
+            'archived_statuses': ConjureFieldDefinition('archivedStatuses', OptionalTypeWrapper[List[api_ArchivedStatus]])
         }
 
-    __slots__: List[str] = ['_sort', '_page_size', '_next_page_token', '_query']
+    __slots__: List[str] = ['_sort', '_page_size', '_next_page_token', '_query', '_archived_statuses']
 
-    def __init__(self, page_size: int, query: "scout_run_api_SearchQuery", sort: "scout_run_api_SortOptions", next_page_token: Optional[str] = None) -> None:
+    def __init__(self, page_size: int, query: "scout_run_api_SearchQuery", sort: "scout_run_api_SortOptions", archived_statuses: Optional[List["api_ArchivedStatus"]] = None, next_page_token: Optional[str] = None) -> None:
         self._sort = sort
         self._page_size = page_size
         self._next_page_token = next_page_token
         self._query = query
+        self._archived_statuses = archived_statuses
 
     @builtins.property
     def sort(self) -> "scout_run_api_SortOptions":
@@ -62797,6 +63703,13 @@ class scout_run_api_SearchRunsRequest(ConjureBeanType):
     def query(self) -> "scout_run_api_SearchQuery":
         return self._query
 
+    @builtins.property
+    def archived_statuses(self) -> Optional[List["api_ArchivedStatus"]]:
+        """
+        Default search status is NOT_ARCHIVED if none are provided. Allows for including archived runs in search.
+        """
+        return self._archived_statuses
+
 
 scout_run_api_SearchRunsRequest.__name__ = "SearchRunsRequest"
 scout_run_api_SearchRunsRequest.__qualname__ = "SearchRunsRequest"
@@ -69763,24 +70676,18 @@ class storage_writer_api_LogValue(ConjureBeanType):
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'raw': ConjureFieldDefinition('raw', str),
-            'message': ConjureFieldDefinition('message', OptionalTypeWrapper[str]),
+            'message': ConjureFieldDefinition('message', str),
             'args': ConjureFieldDefinition('args', Dict[str, str])
         }
 
-    __slots__: List[str] = ['_raw', '_message', '_args']
+    __slots__: List[str] = ['_message', '_args']
 
-    def __init__(self, args: Dict[str, str], raw: str, message: Optional[str] = None) -> None:
-        self._raw = raw
+    def __init__(self, args: Dict[str, str], message: str) -> None:
         self._message = message
         self._args = args
 
     @builtins.property
-    def raw(self) -> str:
-        return self._raw
-
-    @builtins.property
-    def message(self) -> Optional[str]:
+    def message(self) -> str:
         return self._message
 
     @builtins.property
@@ -75107,6 +76014,8 @@ api_rids_ChunkRid = str
 
 scout_rids_api_CheckAlertRid = str
 
+ingest_api_ContainerizedExtractorRid = str
+
 scout_chart_api_JsonString = str
 
 scout_checks_api_JobRid = str
@@ -75161,6 +76070,8 @@ api_TagName = str
 
 authentication_api_UserRid = str
 
+ingest_api_EnvironmentVariable = str
+
 scout_datasource_connection_api_ConnectionRid = str
 
 scout_channelvariables_api_ComputeSpecV1 = str