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

nominal_api/__init__.py

@@ -75,5 +75,5 @@ __all__ = [
 
 __conjure_generator_version__ = "4.9.0"
 
-__version__ = "0.609.0"
+__version__ = "0.610.0"
 

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
 
-ingest_api_CsvOpts.__name__ = "CsvOpts"
-ingest_api_CsvOpts.__qualname__ = "CsvOpts"
-ingest_api_CsvOpts.__module__ = "nominal_api.ingest_api"
+    @builtins.property
+    def created_at(self) -> str:
+        """
+        Timestamp when this extractor was created.
+        """
+        return self._created_at
+
+    @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)
 
-class ingest_api_CustomOpts(ConjureBeanType):
+        _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)
+
+        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
@@ -69763,24 +70632,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 +75970,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 +76026,8 @@ api_TagName = str
 
 authentication_api_UserRid = str
 
+ingest_api_EnvironmentVariable = str
+
 scout_datasource_connection_api_ConnectionRid = str
 
 scout_channelvariables_api_ComputeSpecV1 = str

nominal_api/ingest_api/__init__.py

@@ -3,11 +3,16 @@ from .._impl import (
     ingest_api_AbsoluteTimestamp as AbsoluteTimestamp,
     ingest_api_AbsoluteTimestampVisitor as AbsoluteTimestampVisitor,
     ingest_api_AsyncHandle as AsyncHandle,
+    ingest_api_Authentication as Authentication,
+    ingest_api_AuthenticationVisitor as AuthenticationVisitor,
     ingest_api_ChannelConfig as ChannelConfig,
     ingest_api_ChannelPrefix as ChannelPrefix,
     ingest_api_CompleteMultipartUploadResponse as CompleteMultipartUploadResponse,
+    ingest_api_ContainerizedExtractor as ContainerizedExtractor,
+    ingest_api_ContainerizedExtractorRid as ContainerizedExtractorRid,
+    ingest_api_ContainerizedExtractorService as ContainerizedExtractorService,
+    ingest_api_ContainerizedOpts as ContainerizedOpts,
     ingest_api_CsvOpts as CsvOpts,
-    ingest_api_CustomOpts as CustomOpts,
     ingest_api_CustomTimestamp as CustomTimestamp,
     ingest_api_DataSourceRefName as DataSourceRefName,
     ingest_api_DataflashOpts as DataflashOpts,
@@ -19,11 +24,16 @@ from .._impl import (
     ingest_api_DeprecatedNewDataSourceVisitor as DeprecatedNewDataSourceVisitor,
     ingest_api_DeprecatedTimestampMetadata as DeprecatedTimestampMetadata,
     ingest_api_DeprecatedTriggerIngest as DeprecatedTriggerIngest,
+    ingest_api_DockerImageSource as DockerImageSource,
+    ingest_api_EnvironmentVariable as EnvironmentVariable,
     ingest_api_EpochTimestamp as EpochTimestamp,
     ingest_api_ExistingDatasetIngestDestination as ExistingDatasetIngestDestination,
     ingest_api_ExistingVideoIngestDestination as ExistingVideoIngestDestination,
     ingest_api_ExtractorInputName as ExtractorInputName,
+    ingest_api_FileExtractionInput as FileExtractionInput,
     ingest_api_GcsIngestSource as GcsIngestSource,
+    ingest_api_GetContainerizedExtractorsRequest as GetContainerizedExtractorsRequest,
+    ingest_api_GetContainerizedExtractorsResponse as GetContainerizedExtractorsResponse,
     ingest_api_IngestDataSource as IngestDataSource,
     ingest_api_IngestDataSourceVisitor as IngestDataSourceVisitor,
     ingest_api_IngestDatasetFileDetails as IngestDatasetFileDetails,
@@ -76,11 +86,16 @@ from .._impl import (
     ingest_api_ParquetOpts as ParquetOpts,
     ingest_api_Part as Part,
     ingest_api_PartWithSize as PartWithSize,
+    ingest_api_RegisterContainerizedExtractorRequest as RegisterContainerizedExtractorRequest,
+    ingest_api_RegisterContainerizedExtractorResponse as RegisterContainerizedExtractorResponse,
     ingest_api_RelativeTimestamp as RelativeTimestamp,
     ingest_api_RunRid as RunRid,
     ingest_api_S3IngestSource as S3IngestSource,
     ingest_api_ScaleParameter as ScaleParameter,
     ingest_api_ScaleParameterVisitor as ScaleParameterVisitor,
+    ingest_api_SearchContainerizedExtractorsQuery as SearchContainerizedExtractorsQuery,
+    ingest_api_SearchContainerizedExtractorsQueryVisitor as SearchContainerizedExtractorsQueryVisitor,
+    ingest_api_SearchContainerizedExtractorsRequest as SearchContainerizedExtractorsRequest,
     ingest_api_SignPartResponse as SignPartResponse,
     ingest_api_SkipRowsConfig as SkipRowsConfig,
     ingest_api_TimeOffsetSpec as TimeOffsetSpec,
@@ -92,6 +107,8 @@ from .._impl import (
     ingest_api_TriggerFileIngest as TriggerFileIngest,
     ingest_api_TriggerIngest as TriggerIngest,
     ingest_api_TriggeredIngest as TriggeredIngest,
+    ingest_api_UpdateContainerizedExtractorRequest as UpdateContainerizedExtractorRequest,
+    ingest_api_UserAndPasswordAuthentication as UserAndPasswordAuthentication,
     ingest_api_UtcTimestamp as UtcTimestamp,
     ingest_api_VideoFileIngestDetails as VideoFileIngestDetails,
     ingest_api_VideoIngestTarget as VideoIngestTarget,

{nominal_api-0.609.0.dist-info → nominal_api-0.610.0.dist-info}/METADATA

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

{nominal_api-0.609.0.dist-info → nominal_api-0.610.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
-nominal_api/__init__.py,sha256=dQTea6S4ECozoLcRWhHd0e0eX9T111oNCCepZm1UVCQ,1968
-nominal_api/_impl.py,sha256=Wp_eJzHp5nSlc-pwBdiwcwumVefiBA-2BZkRpT081m8,2913421
+nominal_api/__init__.py,sha256=j6drOnq-fHoXCuF8zNak19e98rrqi7Hd1d7cogsz248,1968
+nominal_api/_impl.py,sha256=cESjkZVtCToHH_7E2sCKdeFgROiEEsAChFITfbLuSFk,2944602
 nominal_api/py.typed,sha256=eoZ6GfifbqhMLNzjlqRDVil-yyBkOmVN9ujSgJWNBlY,15
 nominal_api/api/__init__.py,sha256=kJBEE_HLVpKYdLH12KyO-cSAVzwxYpBwaaDutCtT-LM,1236
 nominal_api/api_ids/__init__.py,sha256=CAtt44XgNZEEUDv-BbEbYtuxQ8y1wqSZU-STjBYdZv8,80
@@ -15,7 +15,7 @@ nominal_api/datasource_logset/__init__.py,sha256=H3fNxqyYC490MwvdWbt5BwhgWQUev7u
 nominal_api/datasource_logset_api/__init__.py,sha256=JyjO1tQmG-HZ7kYMi8lSfeaaYddBZdCMIyqc0IUJfWo,1006
 nominal_api/datasource_pagination_api/__init__.py,sha256=3GO8TAUavOe6dUEitOhje74aSZHjTKVI5N1MNuct1lI,212
 nominal_api/event/__init__.py,sha256=YUhvDFXtyAn08WNd7Xwnybz3PtflvtTcIOaunRS5-1I,836
-nominal_api/ingest_api/__init__.py,sha256=R0c6aMKwtqya4icx6Ffd31jgfQCwrr-yntkg9vOde_0,5673
+nominal_api/ingest_api/__init__.py,sha256=UhryPXVmWzGACR4WrPQaEqAbOdM6XCn0zvyiGNZ6z0w,7010
 nominal_api/persistent_compute_api/__init__.py,sha256=5qZTTfN4X9u_qunFnWbLrPpG_FO5h7YBX68-_F6gYyQ,1031
 nominal_api/scout/__init__.py,sha256=ip3XK_9jJKAoFiCifUVMTpDMiUE4mWIdGzMDu7LASus,324
 nominal_api/scout_api/__init__.py,sha256=biO4DEygbGcLwM6Dg2VuvMra3A5EW6NBjukbIemXoG8,178
@@ -72,7 +72,7 @@ nominal_api/timeseries_logicalseries_api/__init__.py,sha256=Q9iZHurmyDsJIFbUg-Eb
 nominal_api/timeseries_seriescache/__init__.py,sha256=tFCkNuyrVMgtj-HIl1pOYPJHaL2VikI4C_x97bX_Lcs,109
 nominal_api/timeseries_seriescache_api/__init__.py,sha256=U9EhlqdF9qzD1O9al0vcvcdgS_C5lq-lN3Kmr0K3g84,1191
 nominal_api/upload_api/__init__.py,sha256=ZMudWMSqCrNozohbHaJKuxJnT9Edepe7nxxXMz_pT9k,87
-nominal_api-0.609.0.dist-info/METADATA,sha256=I366bMKRF2qePX10r_wshRT_EiLedqOhtyg3SuYLGMY,199
-nominal_api-0.609.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-nominal_api-0.609.0.dist-info/top_level.txt,sha256=gI1ZdNJbuHcJZeKtCzzBXsEtpU1GX6XJKs6ksi_gCRA,12
-nominal_api-0.609.0.dist-info/RECORD,,
+nominal_api-0.610.0.dist-info/METADATA,sha256=JLs5SYFJpBcnGTo16WPSjOzjCmJoXpjfljNd0M924uw,199
+nominal_api-0.610.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+nominal_api-0.610.0.dist-info/top_level.txt,sha256=gI1ZdNJbuHcJZeKtCzzBXsEtpU1GX6XJKs6ksi_gCRA,12
+nominal_api-0.610.0.dist-info/RECORD,,