nominal-api 0.1048.1__py3-none-any.whl → 0.1056.0__py3-none-any.whl

nominal_api/_impl.py

@@ -66,6 +66,38 @@ api_DataSourceType.__qualname__ = "DataSourceType"
 api_DataSourceType.__module__ = "nominal_api.api"
 
 
+class api_Deleted(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+        }
+
+    __slots__: List[str] = []
+
+
+
+api_Deleted.__name__ = "Deleted"
+api_Deleted.__qualname__ = "Deleted"
+api_Deleted.__module__ = "nominal_api.api"
+
+
+class api_DeletionInProgress(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+        }
+
+    __slots__: List[str] = []
+
+
+
+api_DeletionInProgress.__name__ = "DeletionInProgress"
+api_DeletionInProgress.__qualname__ = "DeletionInProgress"
+api_DeletionInProgress.__module__ = "nominal_api.api"
+
+
 class api_Empty(ConjureBeanType):
 
     @builtins.classmethod
@@ -225,13 +257,17 @@ class api_IngestStatusV2(ConjureUnionType):
     _success: Optional["api_SuccessResult"] = None
     _error: Optional["api_ErrorResult"] = None
     _in_progress: Optional["api_InProgressResult"] = None
+    _deletion_in_progress: Optional["api_DeletionInProgress"] = None
+    _deleted: Optional["api_Deleted"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'success': ConjureFieldDefinition('success', api_SuccessResult),
             'error': ConjureFieldDefinition('error', api_ErrorResult),
-            'in_progress': ConjureFieldDefinition('inProgress', api_InProgressResult)
+            'in_progress': ConjureFieldDefinition('inProgress', api_InProgressResult),
+            'deletion_in_progress': ConjureFieldDefinition('deletionInProgress', api_DeletionInProgress),
+            'deleted': ConjureFieldDefinition('deleted', api_Deleted)
         }
 
     def __init__(
@@ -239,10 +275,12 @@ class api_IngestStatusV2(ConjureUnionType):
             success: Optional["api_SuccessResult"] = None,
             error: Optional["api_ErrorResult"] = None,
             in_progress: Optional["api_InProgressResult"] = None,
+            deletion_in_progress: Optional["api_DeletionInProgress"] = None,
+            deleted: Optional["api_Deleted"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (success is not None) + (error is not None) + (in_progress is not None) != 1:
+            if (success is not None) + (error is not None) + (in_progress is not None) + (deletion_in_progress is not None) + (deleted is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if success is not None:
@@ -254,6 +292,12 @@ class api_IngestStatusV2(ConjureUnionType):
             if in_progress is not None:
                 self._in_progress = in_progress
                 self._type = 'inProgress'
+            if deletion_in_progress is not None:
+                self._deletion_in_progress = deletion_in_progress
+                self._type = 'deletionInProgress'
+            if deleted is not None:
+                self._deleted = deleted
+                self._type = 'deleted'
 
         elif type_of_union == 'success':
             if success is None:
@@ -270,6 +314,16 @@ class api_IngestStatusV2(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._in_progress = in_progress
             self._type = 'inProgress'
+        elif type_of_union == 'deletionInProgress':
+            if deletion_in_progress is None:
+                raise ValueError('a union value must not be None')
+            self._deletion_in_progress = deletion_in_progress
+            self._type = 'deletionInProgress'
+        elif type_of_union == 'deleted':
+            if deleted is None:
+                raise ValueError('a union value must not be None')
+            self._deleted = deleted
+            self._type = 'deleted'
 
     @builtins.property
     def success(self) -> Optional["api_SuccessResult"]:
@@ -283,6 +337,14 @@ class api_IngestStatusV2(ConjureUnionType):
     def in_progress(self) -> Optional["api_InProgressResult"]:
         return self._in_progress
 
+    @builtins.property
+    def deletion_in_progress(self) -> Optional["api_DeletionInProgress"]:
+        return self._deletion_in_progress
+
+    @builtins.property
+    def deleted(self) -> Optional["api_Deleted"]:
+        return self._deleted
+
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, api_IngestStatusV2Visitor):
             raise ValueError('{} is not an instance of api_IngestStatusV2Visitor'.format(visitor.__class__.__name__))
@@ -292,6 +354,10 @@ class api_IngestStatusV2(ConjureUnionType):
             return visitor._error(self.error)
         if self._type == 'inProgress' and self.in_progress is not None:
             return visitor._in_progress(self.in_progress)
+        if self._type == 'deletionInProgress' and self.deletion_in_progress is not None:
+            return visitor._deletion_in_progress(self.deletion_in_progress)
+        if self._type == 'deleted' and self.deleted is not None:
+            return visitor._deleted(self.deleted)
 
 
 api_IngestStatusV2.__name__ = "IngestStatusV2"
@@ -313,6 +379,14 @@ class api_IngestStatusV2Visitor:
     def _in_progress(self, in_progress: "api_InProgressResult") -> Any:
         pass
 
+    @abstractmethod
+    def _deletion_in_progress(self, deletion_in_progress: "api_DeletionInProgress") -> Any:
+        pass
+
+    @abstractmethod
+    def _deleted(self, deleted: "api_Deleted") -> Any:
+        pass
+
 
 api_IngestStatusV2Visitor.__name__ = "IngestStatusV2Visitor"
 api_IngestStatusV2Visitor.__qualname__ = "IngestStatusV2Visitor"
@@ -1726,6 +1800,137 @@ Requires authentication with Nominal. This endpoint is intended for internal use
         _decoder = ConjureDecoder()
         return _decoder.decode(_response.json(), authentication_api_GenerateMediaMtxTokenResponse, self._return_none_for_unknown_union_types)
 
+    def get_my_coachmark_dismissals(self, auth_header: str, request: "authentication_api_GetCoachmarkDismissalsRequest") -> "authentication_api_GetCoachmarkDismissalsResponse":
+        """Gets coachmark dismissals for the authenticated user.
+Optionally filter by specific coachmark IDs.
+        """
+        _conjure_encoder = ConjureEncoder()
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, str] = {
+        }
+
+        _json: Any = _conjure_encoder.default(request)
+
+        _path = '/authentication/v2/my/coachmarks/dismissals'
+        _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(), authentication_api_GetCoachmarkDismissalsResponse, self._return_none_for_unknown_union_types)
+
+    def dismiss_my_coachmark(self, auth_header: str, request: "authentication_api_DismissCoachmarkRequest") -> "authentication_api_CoachmarkDismissal":
+        """Dismisses a coachmark for the authenticated user.
+Records the dismissal timestamp and app version.
+        """
+        _conjure_encoder = ConjureEncoder()
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, str] = {
+        }
+
+        _json: Any = _conjure_encoder.default(request)
+
+        _path = '/authentication/v2/my/coachmarks/dismiss'
+        _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(), authentication_api_CoachmarkDismissal, self._return_none_for_unknown_union_types)
+
+    def is_my_coachmark_dismissed(self, auth_header: str, coachmark_id: str) -> bool:
+        """Checks if a specific coachmark has been dismissed by the authenticated user.
+        """
+        _conjure_encoder = ConjureEncoder()
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, str] = {
+            'coachmarkId': quote(str(_conjure_encoder.default(coachmark_id)), safe=''),
+        }
+
+        _json: Any = None
+
+        _path = '/authentication/v2/my/coachmarks/dismissed/{coachmarkId}'
+        _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(), bool, self._return_none_for_unknown_union_types)
+
+    def reset_my_coachmark_dismissal(self, auth_header: str, coachmark_id: str) -> None:
+        """Resets a coachmark dismissal for the authenticated user.
+This allows the coachmark to be shown again.
+Primarily intended for testing and debugging.
+        """
+        _conjure_encoder = ConjureEncoder()
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, str] = {
+            'coachmarkId': quote(str(_conjure_encoder.default(coachmark_id)), safe=''),
+        }
+
+        _json: Any = None
+
+        _path = '/authentication/v2/my/coachmarks/dismissals/{coachmarkId}'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'DELETE',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        return
+
 
 authentication_api_AuthenticationServiceV2.__name__ = "AuthenticationServiceV2"
 authentication_api_AuthenticationServiceV2.__qualname__ = "AuthenticationServiceV2"
@@ -1754,6 +1959,59 @@ authentication_api_ChartTooltipModeSetting.__qualname__ = "ChartTooltipModeSetti
 authentication_api_ChartTooltipModeSetting.__module__ = "nominal_api.authentication_api"
 
 
+class authentication_api_CoachmarkDismissal(ConjureBeanType):
+    """A record of a coachmark dismissal, including when it was dismissed
+and on which app version.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'coachmark_id': ConjureFieldDefinition('coachmarkId', str),
+            'dismissed_at': ConjureFieldDefinition('dismissedAt', str),
+            'app_version': ConjureFieldDefinition('appVersion', str),
+            'step_index': ConjureFieldDefinition('stepIndex', OptionalTypeWrapper[int])
+        }
+
+    __slots__: List[str] = ['_coachmark_id', '_dismissed_at', '_app_version', '_step_index']
+
+    def __init__(self, app_version: str, coachmark_id: str, dismissed_at: str, step_index: Optional[int] = None) -> None:
+        self._coachmark_id = coachmark_id
+        self._dismissed_at = dismissed_at
+        self._app_version = app_version
+        self._step_index = step_index
+
+    @builtins.property
+    def coachmark_id(self) -> str:
+        """The coachmark identifier (typically the feature flag name)
+        """
+        return self._coachmark_id
+
+    @builtins.property
+    def dismissed_at(self) -> str:
+        """ISO 8601 timestamp of when the coachmark was dismissed
+        """
+        return self._dismissed_at
+
+    @builtins.property
+    def app_version(self) -> str:
+        """The apps-scout version (semver) when the coachmark was dismissed
+        """
+        return self._app_version
+
+    @builtins.property
+    def step_index(self) -> Optional[int]:
+        """The step index when dismissed (for multi-step coachmarks).
+If not present, the coachmark was dismissed via the X button.
+        """
+        return self._step_index
+
+
+authentication_api_CoachmarkDismissal.__name__ = "CoachmarkDismissal"
+authentication_api_CoachmarkDismissal.__qualname__ = "CoachmarkDismissal"
+authentication_api_CoachmarkDismissal.__module__ = "nominal_api.authentication_api"
+
+
 class authentication_api_DefaultTimeRangeTypeSetting(ConjureEnumType):
 
     DEFAULT = 'DEFAULT'
@@ -1774,6 +2032,49 @@ authentication_api_DefaultTimeRangeTypeSetting.__qualname__ = "DefaultTimeRangeT
 authentication_api_DefaultTimeRangeTypeSetting.__module__ = "nominal_api.authentication_api"
 
 
+class authentication_api_DismissCoachmarkRequest(ConjureBeanType):
+    """Request to dismiss a coachmark
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'coachmark_id': ConjureFieldDefinition('coachmarkId', str),
+            'app_version': ConjureFieldDefinition('appVersion', str),
+            'step_index': ConjureFieldDefinition('stepIndex', OptionalTypeWrapper[int])
+        }
+
+    __slots__: List[str] = ['_coachmark_id', '_app_version', '_step_index']
+
+    def __init__(self, app_version: str, coachmark_id: str, step_index: Optional[int] = None) -> None:
+        self._coachmark_id = coachmark_id
+        self._app_version = app_version
+        self._step_index = step_index
+
+    @builtins.property
+    def coachmark_id(self) -> str:
+        """The coachmark identifier to dismiss
+        """
+        return self._coachmark_id
+
+    @builtins.property
+    def app_version(self) -> str:
+        """The apps-scout version (semver) when dismissing
+        """
+        return self._app_version
+
+    @builtins.property
+    def step_index(self) -> Optional[int]:
+        """The step index when dismissed (for multi-step coachmarks)
+        """
+        return self._step_index
+
+
+authentication_api_DismissCoachmarkRequest.__name__ = "DismissCoachmarkRequest"
+authentication_api_DismissCoachmarkRequest.__qualname__ = "DismissCoachmarkRequest"
+authentication_api_DismissCoachmarkRequest.__module__ = "nominal_api.authentication_api"
+
+
 class authentication_api_GenerateMediaMtxTokenRequest(ConjureBeanType):
     """Request to generate a MediaMTX authentication token
     """
@@ -1828,6 +2129,61 @@ authentication_api_GenerateMediaMtxTokenResponse.__qualname__ = "GenerateMediaMt
 authentication_api_GenerateMediaMtxTokenResponse.__module__ = "nominal_api.authentication_api"
 
 
+class authentication_api_GetCoachmarkDismissalsRequest(ConjureBeanType):
+    """Request to get coachmark dismissals
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'coachmark_ids': ConjureFieldDefinition('coachmarkIds', OptionalTypeWrapper[List[str]])
+        }
+
+    __slots__: List[str] = ['_coachmark_ids']
+
+    def __init__(self, coachmark_ids: Optional[List[str]] = None) -> None:
+        self._coachmark_ids = coachmark_ids
+
+    @builtins.property
+    def coachmark_ids(self) -> Optional[List[str]]:
+        """Optional list of coachmark IDs to filter by.
+If empty, returns all dismissals for the user.
+        """
+        return self._coachmark_ids
+
+
+authentication_api_GetCoachmarkDismissalsRequest.__name__ = "GetCoachmarkDismissalsRequest"
+authentication_api_GetCoachmarkDismissalsRequest.__qualname__ = "GetCoachmarkDismissalsRequest"
+authentication_api_GetCoachmarkDismissalsRequest.__module__ = "nominal_api.authentication_api"
+
+
+class authentication_api_GetCoachmarkDismissalsResponse(ConjureBeanType):
+    """Response containing coachmark dismissals
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'dismissals': ConjureFieldDefinition('dismissals', Dict[str, authentication_api_CoachmarkDismissal])
+        }
+
+    __slots__: List[str] = ['_dismissals']
+
+    def __init__(self, dismissals: Dict[str, "authentication_api_CoachmarkDismissal"]) -> None:
+        self._dismissals = dismissals
+
+    @builtins.property
+    def dismissals(self) -> Dict[str, "authentication_api_CoachmarkDismissal"]:
+        """Map of coachmark ID to dismissal record
+        """
+        return self._dismissals
+
+
+authentication_api_GetCoachmarkDismissalsResponse.__name__ = "GetCoachmarkDismissalsResponse"
+authentication_api_GetCoachmarkDismissalsResponse.__qualname__ = "GetCoachmarkDismissalsResponse"
+authentication_api_GetCoachmarkDismissalsResponse.__module__ = "nominal_api.authentication_api"
+
+
 class authentication_api_Jwk(ConjureBeanType):
     """A JSON Web Key (JWK) representation for RSA public keys
     """
@@ -17871,6 +18227,35 @@ module_internal_ModuleComputeDefinition.__qualname__ = "ModuleComputeDefinition"
 module_internal_ModuleComputeDefinition.__module__ = "nominal_api.module_internal"
 
 
+class persistent_compute_api_AppendOnlyConfig(ConjureBeanType):
+    """Defines the append results from the websocket.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'decimate_results': ConjureFieldDefinition('decimateResults', bool)
+        }
+
+    __slots__: List[str] = ['_decimate_results']
+
+    def __init__(self, decimate_results: bool) -> None:
+        self._decimate_results = decimate_results
+
+    @builtins.property
+    def decimate_results(self) -> bool:
+        """Specifies whether the returned results should be decimated.
+If this is false, the client may receive a `SubscriptionCreationError` if the data rate is too high
+and responses must be decimated.
+        """
+        return self._decimate_results
+
+
+persistent_compute_api_AppendOnlyConfig.__name__ = "AppendOnlyConfig"
+persistent_compute_api_AppendOnlyConfig.__qualname__ = "AppendOnlyConfig"
+persistent_compute_api_AppendOnlyConfig.__module__ = "nominal_api.persistent_compute_api"
+
+
 class persistent_compute_api_AppendResult(ConjureBeanType):
     """An append result won't cover the full `StreamingComputeNodeRequest#windowWidth` but rather just a smaller 
 window. The end of the window that the append covers is guaranteed to be later than previously sent results.
@@ -18817,6 +19202,62 @@ persistent_compute_api_Pong.__qualname__ = "Pong"
 persistent_compute_api_Pong.__module__ = "nominal_api.persistent_compute_api"
 
 
+class persistent_compute_api_ResultConfiguration(ConjureUnionType):
+    _append_only: Optional["persistent_compute_api_AppendOnlyConfig"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'append_only': ConjureFieldDefinition('appendOnly', persistent_compute_api_AppendOnlyConfig)
+        }
+
+    def __init__(
+            self,
+            append_only: Optional["persistent_compute_api_AppendOnlyConfig"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (append_only is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if append_only is not None:
+                self._append_only = append_only
+                self._type = 'appendOnly'
+
+        elif type_of_union == 'appendOnly':
+            if append_only is None:
+                raise ValueError('a union value must not be None')
+            self._append_only = append_only
+            self._type = 'appendOnly'
+
+    @builtins.property
+    def append_only(self) -> Optional["persistent_compute_api_AppendOnlyConfig"]:
+        return self._append_only
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, persistent_compute_api_ResultConfigurationVisitor):
+            raise ValueError('{} is not an instance of persistent_compute_api_ResultConfigurationVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'appendOnly' and self.append_only is not None:
+            return visitor._append_only(self.append_only)
+
+
+persistent_compute_api_ResultConfiguration.__name__ = "ResultConfiguration"
+persistent_compute_api_ResultConfiguration.__qualname__ = "ResultConfiguration"
+persistent_compute_api_ResultConfiguration.__module__ = "nominal_api.persistent_compute_api"
+
+
+class persistent_compute_api_ResultConfigurationVisitor:
+
+    @abstractmethod
+    def _append_only(self, append_only: "persistent_compute_api_AppendOnlyConfig") -> Any:
+        pass
+
+
+persistent_compute_api_ResultConfigurationVisitor.__name__ = "ResultConfigurationVisitor"
+persistent_compute_api_ResultConfigurationVisitor.__qualname__ = "ResultConfigurationVisitor"
+persistent_compute_api_ResultConfigurationVisitor.__module__ = "nominal_api.persistent_compute_api"
+
+
 class persistent_compute_api_ServerMessage(ConjureUnionType):
     _subscription_update: Optional["persistent_compute_api_SubscriptionUpdateMessage"] = None
     _subscription_creation: Optional["persistent_compute_api_SubscriptionCreationMessage"] = None
@@ -19173,14 +19614,16 @@ class persistent_compute_api_SubscriptionOptions(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'min_delay': ConjureFieldDefinition('minDelay', persistent_compute_api_Milliseconds),
-            'allow_appends': ConjureFieldDefinition('allowAppends', OptionalTypeWrapper[bool])
+            'allow_appends': ConjureFieldDefinition('allowAppends', OptionalTypeWrapper[bool]),
+            'result_configuration': ConjureFieldDefinition('resultConfiguration', OptionalTypeWrapper[persistent_compute_api_ResultConfiguration])
         }
 
-    __slots__: List[str] = ['_min_delay', '_allow_appends']
+    __slots__: List[str] = ['_min_delay', '_allow_appends', '_result_configuration']
 
-    def __init__(self, min_delay: int, allow_appends: Optional[bool] = None) -> None:
+    def __init__(self, min_delay: int, allow_appends: Optional[bool] = None, result_configuration: Optional["persistent_compute_api_ResultConfiguration"] = None) -> None:
         self._min_delay = min_delay
         self._allow_appends = allow_appends
+        self._result_configuration = result_configuration
 
     @builtins.property
     def min_delay(self) -> int:
@@ -19200,6 +19643,13 @@ implement support.
         """
         return self._allow_appends
 
+    @builtins.property
+    def result_configuration(self) -> Optional["persistent_compute_api_ResultConfiguration"]:
+        """Defines the results that are sent for this subscription. If not set, falls back to the behavior 
+defined by `allowAppends`.
+        """
+        return self._result_configuration
+
 
 persistent_compute_api_SubscriptionOptions.__name__ = "SubscriptionOptions"
 persistent_compute_api_SubscriptionOptions.__qualname__ = "SubscriptionOptions"
@@ -19361,6 +19811,24 @@ persistent_compute_api_SubscriptionUpdateMessage.__qualname__ = "SubscriptionUpd
 persistent_compute_api_SubscriptionUpdateMessage.__module__ = "nominal_api.persistent_compute_api"
 
 
+class persistent_compute_api_UnavailableResultConfigurationReason(ConjureEnumType):
+
+    APPENDS_NOT_SUPPORTED_FOR_COMPUTE = 'APPENDS_NOT_SUPPORTED_FOR_COMPUTE'
+    '''APPENDS_NOT_SUPPORTED_FOR_COMPUTE'''
+    TOO_MANY_POINTS_FOR_UNDECIMATED_APPENDS = 'TOO_MANY_POINTS_FOR_UNDECIMATED_APPENDS'
+    '''TOO_MANY_POINTS_FOR_UNDECIMATED_APPENDS'''
+    UNKNOWN = 'UNKNOWN'
+    '''UNKNOWN'''
+
+    def __reduce_ex__(self, proto):
+        return self.__class__, (self.name,)
+
+
+persistent_compute_api_UnavailableResultConfigurationReason.__name__ = "UnavailableResultConfigurationReason"
+persistent_compute_api_UnavailableResultConfigurationReason.__qualname__ = "UnavailableResultConfigurationReason"
+persistent_compute_api_UnavailableResultConfigurationReason.__module__ = "nominal_api.persistent_compute_api"
+
+
 class scout_InternalVersioningService(Service):
     """These endpoints are not intended to be used directly by clients, since
 they require saving resource-specific state associated with new commits.
@@ -24758,18 +25226,20 @@ class scout_catalog_AddFileToDataset(ConjureBeanType):
             'timestamp_metadata': ConjureFieldDefinition('timestampMetadata', OptionalTypeWrapper[scout_catalog_TimestampMetadata]),
             'ingest_tag_metadata': ConjureFieldDefinition('ingestTagMetadata', OptionalTypeWrapper[scout_catalog_IngestTagMetadata]),
             'origin_file_handles': ConjureFieldDefinition('originFileHandles', OptionalTypeWrapper[List[scout_catalog_S3Handle]]),
-            'ingest_job_rid': ConjureFieldDefinition('ingestJobRid', OptionalTypeWrapper[ingest_api_IngestJobRid])
+            'ingest_job_rid': ConjureFieldDefinition('ingestJobRid', OptionalTypeWrapper[ingest_api_IngestJobRid]),
+            'metadata': ConjureFieldDefinition('metadata', OptionalTypeWrapper[scout_catalog_DatasetFileMetadata])
         }
 
-    __slots__: List[str] = ['_handle', '_file_size', '_timestamp_metadata', '_ingest_tag_metadata', '_origin_file_handles', '_ingest_job_rid']
+    __slots__: List[str] = ['_handle', '_file_size', '_timestamp_metadata', '_ingest_tag_metadata', '_origin_file_handles', '_ingest_job_rid', '_metadata']
 
-    def __init__(self, file_size: int, handle: "scout_catalog_Handle", ingest_job_rid: Optional[str] = None, ingest_tag_metadata: Optional["scout_catalog_IngestTagMetadata"] = None, origin_file_handles: Optional[List["scout_catalog_S3Handle"]] = None, timestamp_metadata: Optional["scout_catalog_TimestampMetadata"] = None) -> None:
+    def __init__(self, file_size: int, handle: "scout_catalog_Handle", ingest_job_rid: Optional[str] = None, ingest_tag_metadata: Optional["scout_catalog_IngestTagMetadata"] = None, metadata: Optional["scout_catalog_DatasetFileMetadata"] = None, origin_file_handles: Optional[List["scout_catalog_S3Handle"]] = None, timestamp_metadata: Optional["scout_catalog_TimestampMetadata"] = None) -> None:
         self._handle = handle
         self._file_size = file_size
         self._timestamp_metadata = timestamp_metadata
         self._ingest_tag_metadata = ingest_tag_metadata
         self._origin_file_handles = origin_file_handles
         self._ingest_job_rid = ingest_job_rid
+        self._metadata = metadata
 
     @builtins.property
     def handle(self) -> "scout_catalog_Handle":
@@ -24797,6 +25267,12 @@ class scout_catalog_AddFileToDataset(ConjureBeanType):
     def ingest_job_rid(self) -> Optional[str]:
         return self._ingest_job_rid
 
+    @builtins.property
+    def metadata(self) -> Optional["scout_catalog_DatasetFileMetadata"]:
+        """File-type-specific metadata. For video files, contains timestamp manifest.
+        """
+        return self._metadata
+
 
 scout_catalog_AddFileToDataset.__name__ = "AddFileToDataset"
 scout_catalog_AddFileToDataset.__qualname__ = "AddFileToDataset"
@@ -26714,6 +27190,10 @@ class scout_catalog_IngestStatus(ConjureEnumType):
     '''COMPLETED'''
     FAILED = 'FAILED'
     '''FAILED'''
+    DELETION_IN_PROGRESS = 'DELETION_IN_PROGRESS'
+    '''DELETION_IN_PROGRESS'''
+    DELETED = 'DELETED'
+    '''DELETED'''
     UNKNOWN = 'UNKNOWN'
     '''UNKNOWN'''
 
@@ -90739,9 +91219,14 @@ permanently delete it. Archived videos can be unarchived.
 
         return
 
-    def get_playlist(self, auth_header: str, video_rid: str) -> Any:
-        """Generates an HLS playlist for a video with the given video rid to enable playback. The HLS playlist will contain
-links to all of the segments in the video in sequential order.
+    def get_playlist(self, auth_header: str, video_rid: str, end: Optional[str] = None, start: Optional[str] = None) -> Any:
+        """Generates an HLS playlist for a video within optional time bounds.
+Uses GET with query parameters for HLS.js compatibility.
+The HLS playlist will contain links to all of the segments in the video that overlap with the given bounds,
+or all segments if no bounds are provided.
+
+Note: The start and end parameters must either both be provided or both be omitted.
+Providing only one will result in a MissingTimestampBoundPair error.
         """
         _conjure_encoder = ConjureEncoder()
 
@@ -90751,6 +91236,8 @@ links to all of the segments in the video in sequential order.
         }
 
         _params: Dict[str, Any] = {
+            'start': _conjure_encoder.default(start),
+            'end': _conjure_encoder.default(end),
         }
 
         _path_params: Dict[str, str] = {
@@ -90880,6 +91367,49 @@ bounds then generates a playlist for all matching video segments.
         _raw.decode_content = True
         return _raw
 
+    def get_playlist_for_channel(self, auth_header: str, channel: str, end: str, start: str, asset_rid: Optional[str] = None, data_scope_name: Optional[str] = None, data_source_rid: Optional[str] = None, tags: Optional[str] = None) -> Any:
+        """Generates an HLS playlist for a video channel series within time bounds.
+Specify either dataSourceRid OR (assetRid + dataScopeName) to identify the channel source.
+
+Note: Both start and end parameters are required and must be provided together.
+        """
+        _conjure_encoder = ConjureEncoder()
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/octet-stream',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+            'dataSourceRid': _conjure_encoder.default(data_source_rid),
+            'assetRid': _conjure_encoder.default(asset_rid),
+            'dataScopeName': _conjure_encoder.default(data_scope_name),
+            'channel': _conjure_encoder.default(channel),
+            'tags': _conjure_encoder.default(tags),
+            'start': _conjure_encoder.default(start),
+            'end': _conjure_encoder.default(end),
+        }
+
+        _path_params: Dict[str, str] = {
+        }
+
+        _json: Any = None
+
+        _path = '/video/v1/videos/channel/playlist'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'GET',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            stream=True,
+            json=_json)
+
+        _raw = _response.raw
+        _raw.decode_content = True
+        return _raw
+
     def get_segment_summaries_in_bounds(self, auth_header: str, request: "scout_video_api_GetSegmentSummariesInBoundsRequest", video_rid: str) -> List["scout_video_api_SegmentSummary"]:
         """Returns the min and max absolute and media timestamps for each segment in a video that overlap with an 
 optional set of bounds.