nominal-api 0.581.0__py3-none-any.whl → 0.583.0__py3-none-any.whl

nominal_api/__init__.py

@@ -62,6 +62,8 @@ __all__ = [
     'themes_api',
     'timeseries_archetype',
     'timeseries_archetype_api',
+    'timeseries_channelmetadata',
+    'timeseries_channelmetadata_api',
     'timeseries_logicalseries',
     'timeseries_logicalseries_api',
     'timeseries_seriescache',
@@ -71,5 +73,5 @@ __all__ = [
 
 __conjure_generator_version__ = "4.9.0"
 
-__version__ = "0.581.0"
+__version__ = "0.583.0"
 

nominal_api/_impl.py

@@ -12086,6 +12086,83 @@ scout_api_ChannelLocator.__qualname__ = "ChannelLocator"
 scout_api_ChannelLocator.__module__ = "nominal_api.scout_api"
 
 
+class scout_api_DataScope(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'data_source': ConjureFieldDefinition('dataSource', scout_run_api_DataSource),
+            'offset': ConjureFieldDefinition('offset', scout_run_api_Duration),
+            'ref_name': ConjureFieldDefinition('refName', scout_api_DataSourceRefName),
+            'timestamp_type': ConjureFieldDefinition('timestampType', scout_api_WeakTimestampType),
+            'series_tags': ConjureFieldDefinition('seriesTags', Dict[api_TagName, api_TagValue])
+        }
+
+    __slots__: List[str] = ['_data_source', '_offset', '_ref_name', '_timestamp_type', '_series_tags']
+
+    def __init__(self, data_source: "scout_run_api_DataSource", offset: "scout_run_api_Duration", ref_name: str, series_tags: Dict[str, str], timestamp_type: "scout_api_WeakTimestampType") -> None:
+        self._data_source = data_source
+        self._offset = offset
+        self._ref_name = ref_name
+        self._timestamp_type = timestamp_type
+        self._series_tags = series_tags
+
+    @builtins.property
+    def data_source(self) -> "scout_run_api_DataSource":
+        return self._data_source
+
+    @builtins.property
+    def offset(self) -> "scout_run_api_Duration":
+        """
+        This offset is used for small time-sync corrections. Notably, it is
+not the offset to move a relative data source to the start of the run.
+        """
+        return self._offset
+
+    @builtins.property
+    def ref_name(self) -> str:
+        return self._ref_name
+
+    @builtins.property
+    def timestamp_type(self) -> "scout_api_WeakTimestampType":
+        return self._timestamp_type
+
+    @builtins.property
+    def series_tags(self) -> Dict[str, str]:
+        """
+        Used to resolve logical series for this data source.
+        """
+        return self._series_tags
+
+
+scout_api_DataScope.__name__ = "DataScope"
+scout_api_DataScope.__qualname__ = "DataScope"
+scout_api_DataScope.__module__ = "nominal_api.scout_api"
+
+
+class scout_api_WeakTimestampType(ConjureEnumType):
+    """
+    If a CSV data source is still being split, the timestamp type is not known.
+    """
+
+    ABSOLUTE = 'ABSOLUTE'
+    '''ABSOLUTE'''
+    RELATIVE = 'RELATIVE'
+    '''RELATIVE'''
+    PENDING = 'PENDING'
+    '''PENDING'''
+    UNKNOWN = 'UNKNOWN'
+    '''UNKNOWN'''
+
+    def __reduce_ex__(self, proto):
+        return self.__class__, (self.name,)
+
+
+scout_api_WeakTimestampType.__name__ = "WeakTimestampType"
+scout_api_WeakTimestampType.__qualname__ = "WeakTimestampType"
+scout_api_WeakTimestampType.__module__ = "nominal_api.scout_api"
+
+
 class scout_asset_api_AddDataScopesToAssetRequest(ConjureBeanType):
 
     @builtins.classmethod
@@ -12225,6 +12302,10 @@ scout_asset_api_Asset.__module__ = "nominal_api.scout_asset_api"
 
 
 class scout_asset_api_AssetDataScope(ConjureBeanType):
+    """
+    This type is equivalent to the DataScope type, except it uses a dataScopeName instead of refName. It will
+eventually be deprecated in favor of DataScope.
+    """
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
@@ -12232,13 +12313,13 @@ class scout_asset_api_AssetDataScope(ConjureBeanType):
             'data_scope_name': ConjureFieldDefinition('dataScopeName', scout_asset_api_DataScopeName),
             'data_source': ConjureFieldDefinition('dataSource', scout_run_api_DataSource),
             'offset': ConjureFieldDefinition('offset', OptionalTypeWrapper[scout_run_api_Duration]),
-            'timestamp_type': ConjureFieldDefinition('timestampType', scout_run_api_WeakTimestampType),
+            'timestamp_type': ConjureFieldDefinition('timestampType', scout_api_WeakTimestampType),
             'series_tags': ConjureFieldDefinition('seriesTags', Dict[scout_asset_api_SeriesTagName, scout_asset_api_SeriesTagValue])
         }
 
     __slots__: List[str] = ['_data_scope_name', '_data_source', '_offset', '_timestamp_type', '_series_tags']
 
-    def __init__(self, data_scope_name: str, data_source: "scout_run_api_DataSource", series_tags: Dict[str, str], timestamp_type: "scout_run_api_WeakTimestampType", offset: Optional["scout_run_api_Duration"] = None) -> None:
+    def __init__(self, data_scope_name: str, data_source: "scout_run_api_DataSource", series_tags: Dict[str, str], timestamp_type: "scout_api_WeakTimestampType", offset: Optional["scout_run_api_Duration"] = None) -> None:
         self._data_scope_name = data_scope_name
         self._data_source = data_source
         self._offset = offset
@@ -12261,7 +12342,7 @@ class scout_asset_api_AssetDataScope(ConjureBeanType):
         return self._offset
 
     @builtins.property
-    def timestamp_type(self) -> "scout_run_api_WeakTimestampType":
+    def timestamp_type(self) -> "scout_api_WeakTimestampType":
         return self._timestamp_type
 
     @builtins.property
@@ -60277,16 +60358,17 @@ class scout_run_api_Run(ConjureBeanType):
             'links': ConjureFieldDefinition('links', List[scout_run_api_Link]),
             'created_at': ConjureFieldDefinition('createdAt', str),
             'updated_at': ConjureFieldDefinition('updatedAt', str),
-            'asset_data_scopes': ConjureFieldDefinition('assetDataScopes', List[scout_asset_api_AssetDataScope]),
-            'data_sources': ConjureFieldDefinition('dataSources', Dict[scout_api_DataSourceRefName, scout_run_api_RunDataSource]),
+            'asset_data_scopes': ConjureFieldDefinition('assetDataScopes', List[scout_api_DataScope]),
+            'additional_data_scopes': ConjureFieldDefinition('additionalDataScopes', List[scout_api_DataScope]),
+            'data_sources': ConjureFieldDefinition('dataSources', Dict[scout_api_DataSourceRefName, scout_api_DataScope]),
             'attachments': ConjureFieldDefinition('attachments', List[api_rids_AttachmentRid]),
             'asset': ConjureFieldDefinition('asset', OptionalTypeWrapper[scout_rids_api_AssetRid]),
             'assets': ConjureFieldDefinition('assets', List[scout_rids_api_AssetRid])
         }
 
-    __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', '_additional_data_scopes', '_data_sources', '_attachments', '_asset', '_assets']
 
-    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, additional_data_scopes: List["scout_api_DataScope"], asset_data_scopes: List["scout_api_DataScope"], assets: List[str], attachments: List[str], created_at: str, data_sources: Dict[str, "scout_api_DataScope"], 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:
         self._rid = rid
         self._run_number = run_number
         self._run_prefix = run_prefix
@@ -60301,6 +60383,7 @@ class scout_run_api_Run(ConjureBeanType):
         self._created_at = created_at
         self._updated_at = updated_at
         self._asset_data_scopes = asset_data_scopes
+        self._additional_data_scopes = additional_data_scopes
         self._data_sources = data_sources
         self._attachments = attachments
         self._asset = asset
@@ -60359,14 +60442,24 @@ class scout_run_api_Run(ConjureBeanType):
         return self._updated_at
 
     @builtins.property
-    def asset_data_scopes(self) -> List["scout_asset_api_AssetDataScope"]:
+    def asset_data_scopes(self) -> List["scout_api_DataScope"]:
         """
         returns the data scopes for the assets associated with the run.
         """
         return self._asset_data_scopes
 
     @builtins.property
-    def data_sources(self) -> Dict[str, "scout_run_api_RunDataSource"]:
+    def additional_data_scopes(self) -> List["scout_api_DataScope"]:
+        """
+        returns any data scopes added directly to the run.
+        """
+        return self._additional_data_scopes
+
+    @builtins.property
+    def data_sources(self) -> Dict[str, "scout_api_DataScope"]:
+        """
+        returns all of the data scopes under the run. This includes data scopes of any associated assets. If there are data scopes attached directly to the run that have the same ref name as data scopes from the asset, they will override them.
+        """
         return self._data_sources
 
     @builtins.property
@@ -60464,66 +60557,6 @@ scout_run_api_RunDataReviewSummary.__qualname__ = "RunDataReviewSummary"
 scout_run_api_RunDataReviewSummary.__module__ = "nominal_api.scout_run_api"
 
 
-class scout_run_api_RunDataSource(ConjureBeanType):
-    """
-    For read requests, we want to require all fields
-    """
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'data_source': ConjureFieldDefinition('dataSource', scout_run_api_DataSource),
-            'offset': ConjureFieldDefinition('offset', scout_run_api_Duration),
-            'ref_name': ConjureFieldDefinition('refName', scout_api_DataSourceRefName),
-            'timestamp_type': ConjureFieldDefinition('timestampType', scout_run_api_WeakTimestampType),
-            'series_tags': ConjureFieldDefinition('seriesTags', Dict[api_TagName, api_TagValue])
-        }
-
-    __slots__: List[str] = ['_data_source', '_offset', '_ref_name', '_timestamp_type', '_series_tags']
-
-    def __init__(self, data_source: "scout_run_api_DataSource", offset: "scout_run_api_Duration", ref_name: str, series_tags: Dict[str, str], timestamp_type: "scout_run_api_WeakTimestampType") -> None:
-        self._data_source = data_source
-        self._offset = offset
-        self._ref_name = ref_name
-        self._timestamp_type = timestamp_type
-        self._series_tags = series_tags
-
-    @builtins.property
-    def data_source(self) -> "scout_run_api_DataSource":
-        return self._data_source
-
-    @builtins.property
-    def offset(self) -> "scout_run_api_Duration":
-        """
-        This offset is used for small time-sync corrections. Notably, it is
-not the offset to move a relative data source to the start of the run.
-        """
-        return self._offset
-
-    @builtins.property
-    def ref_name(self) -> str:
-        """
-        Included for convenience, duplicated from the key of the map
-        """
-        return self._ref_name
-
-    @builtins.property
-    def timestamp_type(self) -> "scout_run_api_WeakTimestampType":
-        return self._timestamp_type
-
-    @builtins.property
-    def series_tags(self) -> Dict[str, str]:
-        """
-        Used to resolve logical series for this data source.
-        """
-        return self._series_tags
-
-
-scout_run_api_RunDataSource.__name__ = "RunDataSource"
-scout_run_api_RunDataSource.__qualname__ = "RunDataSource"
-scout_run_api_RunDataSource.__module__ = "nominal_api.scout_run_api"
-
-
 class scout_run_api_RunWithDataReviewMetrics(ConjureBeanType):
 
     @builtins.classmethod
@@ -61378,29 +61411,6 @@ scout_run_api_UtcTimestamp.__qualname__ = "UtcTimestamp"
 scout_run_api_UtcTimestamp.__module__ = "nominal_api.scout_run_api"
 
 
-class scout_run_api_WeakTimestampType(ConjureEnumType):
-    """
-    If a CSV data source is still being split, the timestamp type is not known.
-    """
-
-    ABSOLUTE = 'ABSOLUTE'
-    '''ABSOLUTE'''
-    RELATIVE = 'RELATIVE'
-    '''RELATIVE'''
-    PENDING = 'PENDING'
-    '''PENDING'''
-    UNKNOWN = 'UNKNOWN'
-    '''UNKNOWN'''
-
-    def __reduce_ex__(self, proto):
-        return self.__class__, (self.name,)
-
-
-scout_run_api_WeakTimestampType.__name__ = "WeakTimestampType"
-scout_run_api_WeakTimestampType.__qualname__ = "WeakTimestampType"
-scout_run_api_WeakTimestampType.__module__ = "nominal_api.scout_run_api"
-
-
 class scout_template_api_CommitTemplateRequest(ConjureBeanType):
 
     @builtins.classmethod
@@ -62960,7 +62970,7 @@ class scout_video_VideoFileService(Service):
 
     def batch_get(self, auth_header: str, video_file_rids: List[str] = None) -> List["scout_video_api_VideoFile"]:
         """
-        Returns video file metadata associated with the given video file RIDs.
+        Returns all video files and their metadata associated with the given RIDs
         """
         video_file_rids = video_file_rids if video_file_rids is not None else []
 
@@ -62991,9 +63001,9 @@ class scout_video_VideoFileService(Service):
         _decoder = ConjureDecoder()
         return _decoder.decode(_response.json(), List[scout_video_api_VideoFile], self._return_none_for_unknown_union_types)
 
-    def search(self, auth_header: str, request: "scout_video_api_SearchVideoFilesRequest") -> "scout_video_api_SearchVideoFilesResponse":
+    def list_files_in_video(self, auth_header: str, video_rid: str) -> List["scout_video_api_VideoFile"]:
         """
-        Returns metadata about video files that match a given query.
+        Returns all video files and their metadata associated with the given video RID.
         """
 
         _headers: Dict[str, Any] = {
@@ -63008,9 +63018,9 @@ class scout_video_VideoFileService(Service):
         _path_params: Dict[str, Any] = {
         }
 
-        _json: Any = ConjureEncoder().default(request)
+        _json: Any = ConjureEncoder().default(video_rid)
 
-        _path = '/video-files/v1/video-files/search'
+        _path = '/video-files/v1/video-files/list-files-in-video'
         _path = _path.format(**_path_params)
 
         _response: Response = self._request(
@@ -63021,7 +63031,7 @@ class scout_video_VideoFileService(Service):
             json=_json)
 
         _decoder = ConjureDecoder()
-        return _decoder.decode(_response.json(), scout_video_api_SearchVideoFilesResponse, self._return_none_for_unknown_union_types)
+        return _decoder.decode(_response.json(), List[scout_video_api_VideoFile], self._return_none_for_unknown_union_types)
 
     def update(self, auth_header: str, request: "scout_video_api_UpdateVideoFileRequest", video_file_rid: str) -> "scout_video_api_VideoFile":
         """
@@ -63358,8 +63368,7 @@ at the segment-level.
 
     def get_segment_by_timestamp(self, auth_header: str, request: "scout_video_api_GetSegmentByTimestampRequest", video_rid: str) -> Optional["scout_video_api_Segment"]:
         """
-        Returns metadata for the segment containing the requested absolute timestamp. This endpoint should only be 
-used for videos that were ingested with frame-level timestamps.
+        Returns metadata for the segment within a video containing the requested absolute timestamp.
         """
 
         _headers: Dict[str, Any] = {
@@ -63787,6 +63796,35 @@ scout_video_VideoService.__qualname__ = "VideoService"
 scout_video_VideoService.__module__ = "nominal_api.scout_video"
 
 
+class scout_video_api_Bounds(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'start': ConjureFieldDefinition('start', api_Timestamp),
+            'end': ConjureFieldDefinition('end', api_Timestamp)
+        }
+
+    __slots__: List[str] = ['_start', '_end']
+
+    def __init__(self, end: "api_Timestamp", start: "api_Timestamp") -> None:
+        self._start = start
+        self._end = end
+
+    @builtins.property
+    def start(self) -> "api_Timestamp":
+        return self._start
+
+    @builtins.property
+    def end(self) -> "api_Timestamp":
+        return self._end
+
+
+scout_video_api_Bounds.__name__ = "Bounds"
+scout_video_api_Bounds.__qualname__ = "Bounds"
+scout_video_api_Bounds.__module__ = "nominal_api.scout_video_api"
+
+
 class scout_video_api_CreateSegment(ConjureBeanType):
 
     @builtins.classmethod
@@ -63893,19 +63931,15 @@ class scout_video_api_CreateVideoFileRequest(ConjureBeanType):
         return {
             'title': ConjureFieldDefinition('title', str),
             'description': ConjureFieldDefinition('description', OptionalTypeWrapper[str]),
-            'labels': ConjureFieldDefinition('labels', List[api_Label]),
-            'properties': ConjureFieldDefinition('properties', Dict[api_PropertyName, api_PropertyValue]),
             'origin_metadata': ConjureFieldDefinition('originMetadata', scout_video_api_VideoFileOriginMetadata),
             'video_rid': ConjureFieldDefinition('videoRid', api_rids_VideoRid)
         }
 
-    __slots__: List[str] = ['_title', '_description', '_labels', '_properties', '_origin_metadata', '_video_rid']
+    __slots__: List[str] = ['_title', '_description', '_origin_metadata', '_video_rid']
 
-    def __init__(self, labels: List[str], origin_metadata: "scout_video_api_VideoFileOriginMetadata", properties: Dict[str, str], title: str, video_rid: str, description: Optional[str] = None) -> None:
+    def __init__(self, origin_metadata: "scout_video_api_VideoFileOriginMetadata", title: str, video_rid: str, description: Optional[str] = None) -> None:
         self._title = title
         self._description = description
-        self._labels = labels
-        self._properties = properties
         self._origin_metadata = origin_metadata
         self._video_rid = video_rid
 
@@ -63917,14 +63951,6 @@ class scout_video_api_CreateVideoFileRequest(ConjureBeanType):
     def description(self) -> Optional[str]:
         return self._description
 
-    @builtins.property
-    def labels(self) -> List[str]:
-        return self._labels
-
-    @builtins.property
-    def properties(self) -> Dict[str, str]:
-        return self._properties
-
     @builtins.property
     def origin_metadata(self) -> "scout_video_api_VideoFileOriginMetadata":
         return self._origin_metadata
@@ -64138,18 +64164,31 @@ class scout_video_api_GetSegmentByTimestampRequest(ConjureBeanType):
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'timestamp': ConjureFieldDefinition('timestamp', api_Timestamp)
+            'timestamp': ConjureFieldDefinition('timestamp', api_Timestamp),
+            'view_range_start': ConjureFieldDefinition('viewRangeStart', OptionalTypeWrapper[api_Timestamp])
         }
 
-    __slots__: List[str] = ['_timestamp']
+    __slots__: List[str] = ['_timestamp', '_view_range_start']
 
-    def __init__(self, timestamp: "api_Timestamp") -> None:
+    def __init__(self, timestamp: "api_Timestamp", view_range_start: Optional["api_Timestamp"] = None) -> None:
         self._timestamp = timestamp
+        self._view_range_start = view_range_start
 
     @builtins.property
     def timestamp(self) -> "api_Timestamp":
         return self._timestamp
 
+    @builtins.property
+    def view_range_start(self) -> Optional["api_Timestamp"]:
+        """
+        The start of the view range used to dynamically calculate media timestamps. The first segment with an 
+overlap with the time bounds will have its minimum media timestamp set to 0, with every subsequent
+segment building media time cumulatively from that offset. This will determine the starting media
+timestamp of the returned segment. The view range should be the same as the one requested to get the
+playlist and segment summaries.
+        """
+        return self._view_range_start
+
 
 scout_video_api_GetSegmentByTimestampRequest.__name__ = "GetSegmentByTimestampRequest"
 scout_video_api_GetSegmentByTimestampRequest.__qualname__ = "GetSegmentByTimestampRequest"
@@ -64397,94 +64436,6 @@ scout_video_api_ScaleParameterVisitor.__qualname__ = "ScaleParameterVisitor"
 scout_video_api_ScaleParameterVisitor.__module__ = "nominal_api.scout_video_api"
 
 
-class scout_video_api_SearchVideoFilesRequest(ConjureBeanType):
-    """
-    Request to get video files based on a user-provided query
-    """
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'query': ConjureFieldDefinition('query', scout_video_api_SearchVideosQuery),
-            'page_size': ConjureFieldDefinition('pageSize', OptionalTypeWrapper[int]),
-            'token': ConjureFieldDefinition('token', OptionalTypeWrapper[api_Token]),
-            'sort_options': ConjureFieldDefinition('sortOptions', scout_video_api_SortOptions),
-            'archived_statuses': ConjureFieldDefinition('archivedStatuses', OptionalTypeWrapper[List[api_ArchivedStatus]])
-        }
-
-    __slots__: List[str] = ['_query', '_page_size', '_token', '_sort_options', '_archived_statuses']
-
-    def __init__(self, query: "scout_video_api_SearchVideosQuery", sort_options: "scout_video_api_SortOptions", archived_statuses: Optional[List["api_ArchivedStatus"]] = None, page_size: Optional[int] = None, token: Optional[str] = None) -> None:
-        self._query = query
-        self._page_size = page_size
-        self._token = token
-        self._sort_options = sort_options
-        self._archived_statuses = archived_statuses
-
-    @builtins.property
-    def query(self) -> "scout_video_api_SearchVideosQuery":
-        return self._query
-
-    @builtins.property
-    def page_size(self) -> Optional[int]:
-        """
-        Defaults to 100. Will throw if larger than 1_000.
-        """
-        return self._page_size
-
-    @builtins.property
-    def token(self) -> Optional[str]:
-        return self._token
-
-    @builtins.property
-    def sort_options(self) -> "scout_video_api_SortOptions":
-        return self._sort_options
-
-    @builtins.property
-    def archived_statuses(self) -> Optional[List["api_ArchivedStatus"]]:
-        """
-        Default search status is NOT_ARCHIVED if none are provided.
-        """
-        return self._archived_statuses
-
-
-scout_video_api_SearchVideoFilesRequest.__name__ = "SearchVideoFilesRequest"
-scout_video_api_SearchVideoFilesRequest.__qualname__ = "SearchVideoFilesRequest"
-scout_video_api_SearchVideoFilesRequest.__module__ = "nominal_api.scout_video_api"
-
-
-class scout_video_api_SearchVideoFilesResponse(ConjureBeanType):
-    """
-    Paginated response containing requested video file metadata.
-    """
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'results': ConjureFieldDefinition('results', List[scout_video_api_VideoFile]),
-            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token])
-        }
-
-    __slots__: List[str] = ['_results', '_next_page_token']
-
-    def __init__(self, results: List["scout_video_api_VideoFile"], next_page_token: Optional[str] = None) -> None:
-        self._results = results
-        self._next_page_token = next_page_token
-
-    @builtins.property
-    def results(self) -> List["scout_video_api_VideoFile"]:
-        return self._results
-
-    @builtins.property
-    def next_page_token(self) -> Optional[str]:
-        return self._next_page_token
-
-
-scout_video_api_SearchVideoFilesResponse.__name__ = "SearchVideoFilesResponse"
-scout_video_api_SearchVideoFilesResponse.__qualname__ = "SearchVideoFilesResponse"
-scout_video_api_SearchVideoFilesResponse.__module__ = "nominal_api.scout_video_api"
-
-
 class scout_video_api_SearchVideosQuery(ConjureUnionType):
     _search_text: Optional[str] = None
     _label: Optional[str] = None
@@ -65122,20 +65073,16 @@ class scout_video_api_UpdateVideoFileRequest(ConjureBeanType):
             'video_rid': ConjureFieldDefinition('videoRid', OptionalTypeWrapper[api_rids_VideoRid]),
             'title': ConjureFieldDefinition('title', OptionalTypeWrapper[str]),
             'description': ConjureFieldDefinition('description', OptionalTypeWrapper[str]),
-            'labels': ConjureFieldDefinition('labels', OptionalTypeWrapper[List[api_Label]]),
-            'properties': ConjureFieldDefinition('properties', OptionalTypeWrapper[Dict[api_PropertyName, api_PropertyValue]]),
             'starting_timestamp': ConjureFieldDefinition('startingTimestamp', OptionalTypeWrapper[api_Timestamp]),
             'scale_parameter': ConjureFieldDefinition('scaleParameter', OptionalTypeWrapper[scout_video_api_ScaleParameter])
         }
 
-    __slots__: List[str] = ['_video_rid', '_title', '_description', '_labels', '_properties', '_starting_timestamp', '_scale_parameter']
+    __slots__: List[str] = ['_video_rid', '_title', '_description', '_starting_timestamp', '_scale_parameter']
 
-    def __init__(self, description: Optional[str] = None, labels: Optional[List[str]] = None, properties: Optional[Dict[str, str]] = None, scale_parameter: Optional["scout_video_api_ScaleParameter"] = None, starting_timestamp: Optional["api_Timestamp"] = None, title: Optional[str] = None, video_rid: Optional[str] = None) -> None:
+    def __init__(self, description: Optional[str] = None, scale_parameter: Optional["scout_video_api_ScaleParameter"] = None, starting_timestamp: Optional["api_Timestamp"] = None, title: Optional[str] = None, video_rid: Optional[str] = None) -> None:
         self._video_rid = video_rid
         self._title = title
         self._description = description
-        self._labels = labels
-        self._properties = properties
         self._starting_timestamp = starting_timestamp
         self._scale_parameter = scale_parameter
 
@@ -65151,14 +65098,6 @@ class scout_video_api_UpdateVideoFileRequest(ConjureBeanType):
     def description(self) -> Optional[str]:
         return self._description
 
-    @builtins.property
-    def labels(self) -> Optional[List[str]]:
-        return self._labels
-
-    @builtins.property
-    def properties(self) -> Optional[Dict[str, str]]:
-        return self._properties
-
     @builtins.property
     def starting_timestamp(self) -> Optional["api_Timestamp"]:
         return self._starting_timestamp
@@ -65416,23 +65355,19 @@ class scout_video_api_VideoFile(ConjureBeanType):
             'video_rid': ConjureFieldDefinition('videoRid', api_rids_VideoRid),
             'title': ConjureFieldDefinition('title', str),
             'description': ConjureFieldDefinition('description', OptionalTypeWrapper[str]),
-            'labels': ConjureFieldDefinition('labels', List[api_Label]),
-            'properties': ConjureFieldDefinition('properties', Dict[api_PropertyName, api_PropertyValue]),
             'created_by': ConjureFieldDefinition('createdBy', str),
             'created_at': ConjureFieldDefinition('createdAt', str),
             'origin_metadata': ConjureFieldDefinition('originMetadata', scout_video_api_VideoFileOriginMetadata),
             'segment_metadata': ConjureFieldDefinition('segmentMetadata', OptionalTypeWrapper[scout_video_api_VideoFileSegmentsMetadata])
         }
 
-    __slots__: List[str] = ['_rid', '_video_rid', '_title', '_description', '_labels', '_properties', '_created_by', '_created_at', '_origin_metadata', '_segment_metadata']
+    __slots__: List[str] = ['_rid', '_video_rid', '_title', '_description', '_created_by', '_created_at', '_origin_metadata', '_segment_metadata']
 
-    def __init__(self, created_at: str, created_by: str, labels: List[str], origin_metadata: "scout_video_api_VideoFileOriginMetadata", properties: Dict[str, str], rid: str, title: str, video_rid: str, description: Optional[str] = None, segment_metadata: Optional["scout_video_api_VideoFileSegmentsMetadata"] = None) -> None:
+    def __init__(self, created_at: str, created_by: str, origin_metadata: "scout_video_api_VideoFileOriginMetadata", rid: str, title: str, video_rid: str, description: Optional[str] = None, segment_metadata: Optional["scout_video_api_VideoFileSegmentsMetadata"] = None) -> None:
         self._rid = rid
         self._video_rid = video_rid
         self._title = title
         self._description = description
-        self._labels = labels
-        self._properties = properties
         self._created_by = created_by
         self._created_at = created_at
         self._origin_metadata = origin_metadata
@@ -65454,14 +65389,6 @@ class scout_video_api_VideoFile(ConjureBeanType):
     def description(self) -> Optional[str]:
         return self._description
 
-    @builtins.property
-    def labels(self) -> List[str]:
-        return self._labels
-
-    @builtins.property
-    def properties(self) -> Dict[str, str]:
-        return self._properties
-
     @builtins.property
     def created_by(self) -> str:
         return self._created_by
@@ -70160,6 +70087,367 @@ timeseries_archetype_api_VisualCrossingLocatorTemplate.__qualname__ = "VisualCro
 timeseries_archetype_api_VisualCrossingLocatorTemplate.__module__ = "nominal_api.timeseries_archetype_api"
 
 
+class timeseries_channelmetadata_ChannelMetadataService(Service):
+    """
+    Endpoints for retrieving and updating channel metadata.
+    """
+
+    def get_channel_metadata(self, auth_header: str, request: "timeseries_channelmetadata_api_GetChannelMetadataRequest") -> "timeseries_channelmetadata_api_ChannelMetadata":
+        """
+        Get the metadata for a channel.
+        """
+
+        _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 = '/timeseries/channel-metadata/v1/channel-metadata/get'
+        _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(), timeseries_channelmetadata_api_ChannelMetadata, self._return_none_for_unknown_union_types)
+
+    def batch_get_channel_metadata(self, auth_header: str, request: "timeseries_channelmetadata_api_BatchGetChannelMetadataRequest") -> "timeseries_channelmetadata_api_BatchGetChannelMetadataResponse":
+        """
+        Batch get the metadata for multiple channels. If some channels cannot be found or authorized, 
+they will be omitted from the response.
+        """
+
+        _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 = '/timeseries/channel-metadata/v1/channel-metadata/batch-get'
+        _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(), timeseries_channelmetadata_api_BatchGetChannelMetadataResponse, self._return_none_for_unknown_union_types)
+
+    def update_channel_metadata(self, auth_header: str, request: "timeseries_channelmetadata_api_UpdateChannelMetadataRequest") -> "timeseries_channelmetadata_api_ChannelMetadata":
+        """
+        Update the metadata for a channel.
+        """
+
+        _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 = '/timeseries/channel-metadata/v1/channel-metadata/update'
+        _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(), timeseries_channelmetadata_api_ChannelMetadata, self._return_none_for_unknown_union_types)
+
+    def batch_update_channel_metadata(self, auth_header: str, request: "timeseries_channelmetadata_api_BatchUpdateChannelMetadataRequest") -> "timeseries_channelmetadata_api_BatchUpdateChannelMetadataResponse":
+        """
+        Batch update the metadata for multiple channels. If some channels cannot be found or authorized,
+no metadata will be updated for any of the channels in the request.
+        """
+
+        _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 = '/timeseries/channel-metadata/v1/channel-metadata/batch-update'
+        _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(), timeseries_channelmetadata_api_BatchUpdateChannelMetadataResponse, self._return_none_for_unknown_union_types)
+
+
+timeseries_channelmetadata_ChannelMetadataService.__name__ = "ChannelMetadataService"
+timeseries_channelmetadata_ChannelMetadataService.__qualname__ = "ChannelMetadataService"
+timeseries_channelmetadata_ChannelMetadataService.__module__ = "nominal_api.timeseries_channelmetadata"
+
+
+class timeseries_channelmetadata_api_BatchGetChannelMetadataRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'requests': ConjureFieldDefinition('requests', List[timeseries_channelmetadata_api_GetChannelMetadataRequest])
+        }
+
+    __slots__: List[str] = ['_requests']
+
+    def __init__(self, requests: List["timeseries_channelmetadata_api_GetChannelMetadataRequest"]) -> None:
+        self._requests = requests
+
+    @builtins.property
+    def requests(self) -> List["timeseries_channelmetadata_api_GetChannelMetadataRequest"]:
+        return self._requests
+
+
+timeseries_channelmetadata_api_BatchGetChannelMetadataRequest.__name__ = "BatchGetChannelMetadataRequest"
+timeseries_channelmetadata_api_BatchGetChannelMetadataRequest.__qualname__ = "BatchGetChannelMetadataRequest"
+timeseries_channelmetadata_api_BatchGetChannelMetadataRequest.__module__ = "nominal_api.timeseries_channelmetadata_api"
+
+
+class timeseries_channelmetadata_api_BatchGetChannelMetadataResponse(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'responses': ConjureFieldDefinition('responses', List[timeseries_channelmetadata_api_ChannelMetadata])
+        }
+
+    __slots__: List[str] = ['_responses']
+
+    def __init__(self, responses: List["timeseries_channelmetadata_api_ChannelMetadata"]) -> None:
+        self._responses = responses
+
+    @builtins.property
+    def responses(self) -> List["timeseries_channelmetadata_api_ChannelMetadata"]:
+        return self._responses
+
+
+timeseries_channelmetadata_api_BatchGetChannelMetadataResponse.__name__ = "BatchGetChannelMetadataResponse"
+timeseries_channelmetadata_api_BatchGetChannelMetadataResponse.__qualname__ = "BatchGetChannelMetadataResponse"
+timeseries_channelmetadata_api_BatchGetChannelMetadataResponse.__module__ = "nominal_api.timeseries_channelmetadata_api"
+
+
+class timeseries_channelmetadata_api_BatchUpdateChannelMetadataRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'requests': ConjureFieldDefinition('requests', List[timeseries_channelmetadata_api_UpdateChannelMetadataRequest])
+        }
+
+    __slots__: List[str] = ['_requests']
+
+    def __init__(self, requests: List["timeseries_channelmetadata_api_UpdateChannelMetadataRequest"]) -> None:
+        self._requests = requests
+
+    @builtins.property
+    def requests(self) -> List["timeseries_channelmetadata_api_UpdateChannelMetadataRequest"]:
+        return self._requests
+
+
+timeseries_channelmetadata_api_BatchUpdateChannelMetadataRequest.__name__ = "BatchUpdateChannelMetadataRequest"
+timeseries_channelmetadata_api_BatchUpdateChannelMetadataRequest.__qualname__ = "BatchUpdateChannelMetadataRequest"
+timeseries_channelmetadata_api_BatchUpdateChannelMetadataRequest.__module__ = "nominal_api.timeseries_channelmetadata_api"
+
+
+class timeseries_channelmetadata_api_BatchUpdateChannelMetadataResponse(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'responses': ConjureFieldDefinition('responses', List[timeseries_channelmetadata_api_ChannelMetadata])
+        }
+
+    __slots__: List[str] = ['_responses']
+
+    def __init__(self, responses: List["timeseries_channelmetadata_api_ChannelMetadata"]) -> None:
+        self._responses = responses
+
+    @builtins.property
+    def responses(self) -> List["timeseries_channelmetadata_api_ChannelMetadata"]:
+        return self._responses
+
+
+timeseries_channelmetadata_api_BatchUpdateChannelMetadataResponse.__name__ = "BatchUpdateChannelMetadataResponse"
+timeseries_channelmetadata_api_BatchUpdateChannelMetadataResponse.__qualname__ = "BatchUpdateChannelMetadataResponse"
+timeseries_channelmetadata_api_BatchUpdateChannelMetadataResponse.__module__ = "nominal_api.timeseries_channelmetadata_api"
+
+
+class timeseries_channelmetadata_api_ChannelIdentifier(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'channel_name': ConjureFieldDefinition('channelName', api_Channel),
+            'data_source_rid': ConjureFieldDefinition('dataSourceRid', api_rids_DataSourceRid)
+        }
+
+    __slots__: List[str] = ['_channel_name', '_data_source_rid']
+
+    def __init__(self, channel_name: str, data_source_rid: str) -> None:
+        self._channel_name = channel_name
+        self._data_source_rid = data_source_rid
+
+    @builtins.property
+    def channel_name(self) -> str:
+        return self._channel_name
+
+    @builtins.property
+    def data_source_rid(self) -> str:
+        return self._data_source_rid
+
+
+timeseries_channelmetadata_api_ChannelIdentifier.__name__ = "ChannelIdentifier"
+timeseries_channelmetadata_api_ChannelIdentifier.__qualname__ = "ChannelIdentifier"
+timeseries_channelmetadata_api_ChannelIdentifier.__module__ = "nominal_api.timeseries_channelmetadata_api"
+
+
+class timeseries_channelmetadata_api_ChannelMetadata(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'channel_identifier': ConjureFieldDefinition('channelIdentifier', timeseries_channelmetadata_api_ChannelIdentifier),
+            'description': ConjureFieldDefinition('description', OptionalTypeWrapper[str]),
+            'unit': ConjureFieldDefinition('unit', OptionalTypeWrapper[api_Unit]),
+            'data_type': ConjureFieldDefinition('dataType', OptionalTypeWrapper[api_SeriesDataType])
+        }
+
+    __slots__: List[str] = ['_channel_identifier', '_description', '_unit', '_data_type']
+
+    def __init__(self, channel_identifier: "timeseries_channelmetadata_api_ChannelIdentifier", data_type: Optional["api_SeriesDataType"] = None, description: Optional[str] = None, unit: Optional[str] = None) -> None:
+        self._channel_identifier = channel_identifier
+        self._description = description
+        self._unit = unit
+        self._data_type = data_type
+
+    @builtins.property
+    def channel_identifier(self) -> "timeseries_channelmetadata_api_ChannelIdentifier":
+        return self._channel_identifier
+
+    @builtins.property
+    def description(self) -> Optional[str]:
+        return self._description
+
+    @builtins.property
+    def unit(self) -> Optional[str]:
+        return self._unit
+
+    @builtins.property
+    def data_type(self) -> Optional["api_SeriesDataType"]:
+        return self._data_type
+
+
+timeseries_channelmetadata_api_ChannelMetadata.__name__ = "ChannelMetadata"
+timeseries_channelmetadata_api_ChannelMetadata.__qualname__ = "ChannelMetadata"
+timeseries_channelmetadata_api_ChannelMetadata.__module__ = "nominal_api.timeseries_channelmetadata_api"
+
+
+class timeseries_channelmetadata_api_GetChannelMetadataRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'channel_identifier': ConjureFieldDefinition('channelIdentifier', timeseries_channelmetadata_api_ChannelIdentifier)
+        }
+
+    __slots__: List[str] = ['_channel_identifier']
+
+    def __init__(self, channel_identifier: "timeseries_channelmetadata_api_ChannelIdentifier") -> None:
+        self._channel_identifier = channel_identifier
+
+    @builtins.property
+    def channel_identifier(self) -> "timeseries_channelmetadata_api_ChannelIdentifier":
+        return self._channel_identifier
+
+
+timeseries_channelmetadata_api_GetChannelMetadataRequest.__name__ = "GetChannelMetadataRequest"
+timeseries_channelmetadata_api_GetChannelMetadataRequest.__qualname__ = "GetChannelMetadataRequest"
+timeseries_channelmetadata_api_GetChannelMetadataRequest.__module__ = "nominal_api.timeseries_channelmetadata_api"
+
+
+class timeseries_channelmetadata_api_UpdateChannelMetadataRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'channel_identifier': ConjureFieldDefinition('channelIdentifier', timeseries_channelmetadata_api_ChannelIdentifier),
+            'description': ConjureFieldDefinition('description', OptionalTypeWrapper[str]),
+            'unit_update': ConjureFieldDefinition('unitUpdate', OptionalTypeWrapper[timeseries_logicalseries_api_UnitUpdate])
+        }
+
+    __slots__: List[str] = ['_channel_identifier', '_description', '_unit_update']
+
+    def __init__(self, channel_identifier: "timeseries_channelmetadata_api_ChannelIdentifier", description: Optional[str] = None, unit_update: Optional["timeseries_logicalseries_api_UnitUpdate"] = None) -> None:
+        self._channel_identifier = channel_identifier
+        self._description = description
+        self._unit_update = unit_update
+
+    @builtins.property
+    def channel_identifier(self) -> "timeseries_channelmetadata_api_ChannelIdentifier":
+        return self._channel_identifier
+
+    @builtins.property
+    def description(self) -> Optional[str]:
+        return self._description
+
+    @builtins.property
+    def unit_update(self) -> Optional["timeseries_logicalseries_api_UnitUpdate"]:
+        return self._unit_update
+
+
+timeseries_channelmetadata_api_UpdateChannelMetadataRequest.__name__ = "UpdateChannelMetadataRequest"
+timeseries_channelmetadata_api_UpdateChannelMetadataRequest.__qualname__ = "UpdateChannelMetadataRequest"
+timeseries_channelmetadata_api_UpdateChannelMetadataRequest.__module__ = "nominal_api.timeseries_channelmetadata_api"
+
+
 class timeseries_logicalseries_LogicalSeriesService(Service):
     """
     A logical series is a timeseries, represented by a channel name and a tag set.

nominal_api/scout_api/__init__.py

@@ -1,7 +1,9 @@
 # coding=utf-8
 from .._impl import (
     scout_api_ChannelLocator as ChannelLocator,
+    scout_api_DataScope as DataScope,
     scout_api_DataSourceRefName as DataSourceRefName,
     scout_api_HexColor as HexColor,
+    scout_api_WeakTimestampType as WeakTimestampType,
 )
 

nominal_api/scout_run_api/__init__.py

@@ -24,7 +24,6 @@ from .._impl import (
     scout_run_api_Run as Run,
     scout_run_api_RunDataReviewEvaluationStatus as RunDataReviewEvaluationStatus,
     scout_run_api_RunDataReviewSummary as RunDataReviewSummary,
-    scout_run_api_RunDataSource as RunDataSource,
     scout_run_api_RunRid as RunRid,
     scout_run_api_RunWithDataReviewMetrics as RunWithDataReviewMetrics,
     scout_run_api_RunWithDataReviewSummary as RunWithDataReviewSummary,
@@ -42,6 +41,5 @@ from .._impl import (
     scout_run_api_UpdateAttachmentsRequest as UpdateAttachmentsRequest,
     scout_run_api_UpdateRunRequest as UpdateRunRequest,
     scout_run_api_UtcTimestamp as UtcTimestamp,
-    scout_run_api_WeakTimestampType as WeakTimestampType,
 )
 

nominal_api/scout_video_api/__init__.py

@@ -1,5 +1,6 @@
 # coding=utf-8
 from .._impl import (
+    scout_video_api_Bounds as Bounds,
     scout_video_api_CreateSegment as CreateSegment,
     scout_video_api_CreateSegmentsRequest as CreateSegmentsRequest,
     scout_video_api_CreateSegmentsResponse as CreateSegmentsResponse,
@@ -18,8 +19,6 @@ from .._impl import (
     scout_video_api_NoTimestampManifest as NoTimestampManifest,
     scout_video_api_ScaleParameter as ScaleParameter,
     scout_video_api_ScaleParameterVisitor as ScaleParameterVisitor,
-    scout_video_api_SearchVideoFilesRequest as SearchVideoFilesRequest,
-    scout_video_api_SearchVideoFilesResponse as SearchVideoFilesResponse,
     scout_video_api_SearchVideosQuery as SearchVideosQuery,
     scout_video_api_SearchVideosQueryVisitor as SearchVideosQueryVisitor,
     scout_video_api_SearchVideosRequest as SearchVideosRequest,

nominal_api/timeseries_channelmetadata/__init__.py

@@ -0,0 +1,5 @@
+# coding=utf-8
+from .._impl import (
+    timeseries_channelmetadata_ChannelMetadataService as ChannelMetadataService,
+)
+

nominal_api/timeseries_channelmetadata_api/__init__.py

@@ -0,0 +1,12 @@
+# coding=utf-8
+from .._impl import (
+    timeseries_channelmetadata_api_BatchGetChannelMetadataRequest as BatchGetChannelMetadataRequest,
+    timeseries_channelmetadata_api_BatchGetChannelMetadataResponse as BatchGetChannelMetadataResponse,
+    timeseries_channelmetadata_api_BatchUpdateChannelMetadataRequest as BatchUpdateChannelMetadataRequest,
+    timeseries_channelmetadata_api_BatchUpdateChannelMetadataResponse as BatchUpdateChannelMetadataResponse,
+    timeseries_channelmetadata_api_ChannelIdentifier as ChannelIdentifier,
+    timeseries_channelmetadata_api_ChannelMetadata as ChannelMetadata,
+    timeseries_channelmetadata_api_GetChannelMetadataRequest as GetChannelMetadataRequest,
+    timeseries_channelmetadata_api_UpdateChannelMetadataRequest as UpdateChannelMetadataRequest,
+)
+

{nominal_api-0.581.0.dist-info → nominal_api-0.583.0.dist-info}/METADATA

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

{nominal_api-0.581.0.dist-info → nominal_api-0.583.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
-nominal_api/__init__.py,sha256=6yqLNRrqju-nVKl3EjwtwKUAHgUQzn7gg9Qi3mQt4r0,1851
-nominal_api/_impl.py,sha256=EJPjxUD5HHHEDm3NcIcUgWZ-KCQ1HIHWewQ9ngI4gds,2816995
+nominal_api/__init__.py,sha256=UEab9bYWoYZrUMrjgrx5oCy2UhH1eqILcgybDb7Suv4,1923
+nominal_api/_impl.py,sha256=SmmRHxvjIfCschNcX1Ov1_Tj22zGvGyW64PZ3oLPQyA,2828599
 nominal_api/py.typed,sha256=eoZ6GfifbqhMLNzjlqRDVil-yyBkOmVN9ujSgJWNBlY,15
 nominal_api/api/__init__.py,sha256=kJBEE_HLVpKYdLH12KyO-cSAVzwxYpBwaaDutCtT-LM,1236
 nominal_api/api_rids/__init__.py,sha256=Bu-pKUh3aS9_f5m-DZf6W_BUlVo9qYE7EDvaT-rvWQ0,423
@@ -16,7 +16,7 @@ nominal_api/datasource_pagination_api/__init__.py,sha256=3GO8TAUavOe6dUEitOhje74
 nominal_api/event/__init__.py,sha256=YUhvDFXtyAn08WNd7Xwnybz3PtflvtTcIOaunRS5-1I,836
 nominal_api/ingest_api/__init__.py,sha256=U4rA8WoGLgVr8yzWcigZijvOOy13BYYzpz5ium94sp4,5532
 nominal_api/scout/__init__.py,sha256=ip3XK_9jJKAoFiCifUVMTpDMiUE4mWIdGzMDu7LASus,324
-nominal_api/scout_api/__init__.py,sha256=biO4DEygbGcLwM6Dg2VuvMra3A5EW6NBjukbIemXoG8,178
+nominal_api/scout_api/__init__.py,sha256=zl03M5lLjNaxN9WxRgx96xKYWwked6WM6nfxSFnak4Q,270
 nominal_api/scout_asset_api/__init__.py,sha256=Ph-KlW-ki0JRejYQZDvbZ2jRzNAttVBux27lcEj7--Q,1910
 nominal_api/scout_assets/__init__.py,sha256=dT-b9HnbwVbI-fEalfskKSMGzhGRwZDZ2cdzWul1daY,87
 nominal_api/scout_catalog/__init__.py,sha256=ZGm4w1YKd4B-3CNxijTpB-1B653nctA_R0u24oPS3To,3508
@@ -47,12 +47,12 @@ nominal_api/scout_metadata/__init__.py,sha256=GIhWKJL2XSMB0iGaKfcGgmPHuvGWWmkK4l
 nominal_api/scout_notebook_api/__init__.py,sha256=QW0vg8ZrAmuctjnNLxTnqtwyQoX-H9MOkHlLWioe5AA,1230
 nominal_api/scout_plotting/__init__.py,sha256=m6u3y7R70mo3ugaCp_-fwlS8_tDwrsq1l5ElOTY0TBc,91
 nominal_api/scout_rids_api/__init__.py,sha256=zAioy5BpuLLgZQpF-11wWUEhntcHNj6sK5YzNC5z-3w,1188
-nominal_api/scout_run_api/__init__.py,sha256=lTAFwaHSqRs7dx316MzdQcgdBy7Y_fe_BbfbaktaZGs,2596
+nominal_api/scout_run_api/__init__.py,sha256=3ITK86gMknGWi9RaHs4XmB3Xx16AHAL8GPPe1OwpVJk,2488
 nominal_api/scout_template_api/__init__.py,sha256=bsu8qPiZ4gf67G5iFvwsfkqEKJRZ7L5Wyg6qcFyogO0,1037
 nominal_api/scout_units_api/__init__.py,sha256=KxRDScfumX__0ncWJftGvgApn_LBTfnIBAvnaBrcA5A,368
 nominal_api/scout_versioning_api/__init__.py,sha256=Sf4T4t0rZXNRIZgkqLBN3yh0sAnrxiuzaTfDQVVkyO4,1323
 nominal_api/scout_video/__init__.py,sha256=zB7mM23yGAgC529rF4gjDmqcLRbsp0kJA3xef8meZko,200
-nominal_api/scout_video_api/__init__.py,sha256=ns_kzZuuZPmvsFgMrX7n5xDktmOKw4iBExe7QtuowMA,3242
+nominal_api/scout_video_api/__init__.py,sha256=uV--adN5Su2PiKDpbeeIQj2qWghdh5YFzNT8u-6rPYY,3134
 nominal_api/scout_workbookcommon_api/__init__.py,sha256=6Ai0cYNOOw2A6JOlKzraTbpZwolspM-WTqVGLMN2HdI,413
 nominal_api/secrets_api/__init__.py,sha256=V5BpnbNzjdMP8kgvR2N6SEVcVyXi6Vyl_lh_5fKjJzw,736
 nominal_api/security_api_workspace/__init__.py,sha256=18MQr8sUGDfaXl50sMR7objE5rBJ9dZ1Sjwuyf997dA,156
@@ -63,12 +63,14 @@ nominal_api/storage_writer_api/__init__.py,sha256=kr14YqN44wGfHJIy_7hti6KFq5caA1
 nominal_api/themes_api/__init__.py,sha256=w-G93T5f6_2zSSUi-ffyUHxH8QA_2oI9jM7YBSMFpwY,924
 nominal_api/timeseries_archetype/__init__.py,sha256=eKdgdZoOcZg_9pmec6J86NlgQdhxhi1282WUAFxghJ8,115
 nominal_api/timeseries_archetype_api/__init__.py,sha256=IREibRlChT9ugCAkeMKm7RiAChsKV4KJZ-DcKkVLC_U,1396
+nominal_api/timeseries_channelmetadata/__init__.py,sha256=DdcwwrIydiRIFiEvxAqcTtVmhT6Wy64kAO9e2j4z4sI,121
+nominal_api/timeseries_channelmetadata_api/__init__.py,sha256=g8kC5TrYcF_jrqKec1qbYBoUrVaoTiCd8NsDO3mXGxk,794
 nominal_api/timeseries_logicalseries/__init__.py,sha256=8EkKiSUli5RbCEf6CPmkiTUOyFcdiNj292eV0WgVbrs,115
 nominal_api/timeseries_logicalseries_api/__init__.py,sha256=7NlQhIzOKOcjwMNUI89fn9BIEOdu3i9l6wUJWc_gcig,3638
 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.581.0.dist-info/METADATA,sha256=Mlplin3s8eBjh5X21n6jesHpQU_7lAiGTyrfq2EtZe0,199
-nominal_api-0.581.0.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-nominal_api-0.581.0.dist-info/top_level.txt,sha256=gI1ZdNJbuHcJZeKtCzzBXsEtpU1GX6XJKs6ksi_gCRA,12
-nominal_api-0.581.0.dist-info/RECORD,,
+nominal_api-0.583.0.dist-info/METADATA,sha256=GRnJvQvUaodUuBW1bg1GEepXRoRISLdRob5d_hGukn8,199
+nominal_api-0.583.0.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
+nominal_api-0.583.0.dist-info/top_level.txt,sha256=gI1ZdNJbuHcJZeKtCzzBXsEtpU1GX6XJKs6ksi_gCRA,12
+nominal_api-0.583.0.dist-info/RECORD,,