nominal-api 0.602.0__py3-none-any.whl → 0.604.0__py3-none-any.whl

nominal_api/_impl.py

@@ -944,7 +944,7 @@ class attachments_api_CreateAttachmentRequest(ConjureBeanType):
             'description': ConjureFieldDefinition('description', str),
             'properties': ConjureFieldDefinition('properties', Dict[api_PropertyName, api_PropertyValue]),
             'labels': ConjureFieldDefinition('labels', List[api_Label]),
-            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_ids_WorkspaceId])
+            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_rids_WorkspaceRid])
         }
 
     __slots__: List[str] = ['_s3_path', '_title', '_description', '_properties', '_labels', '_workspace']
@@ -1054,7 +1054,7 @@ class attachments_api_SearchAttachmentsQuery(ConjureUnionType):
             'property': ConjureFieldDefinition('property', api_Property),
             'and_': ConjureFieldDefinition('and', List[attachments_api_SearchAttachmentsQuery]),
             'or_': ConjureFieldDefinition('or', List[attachments_api_SearchAttachmentsQuery]),
-            'workspace': ConjureFieldDefinition('workspace', api_ids_WorkspaceId)
+            'workspace': ConjureFieldDefinition('workspace', api_rids_WorkspaceRid)
         }
 
     def __init__(
@@ -1240,1589 +1240,6 @@ attachments_api_UpdateAttachmentRequest.__qualname__ = "UpdateAttachmentRequest"
 attachments_api_UpdateAttachmentRequest.__module__ = "nominal_api.attachments_api"
 
 
-class authentication_api_AppearanceSetting(ConjureEnumType):
-
-    SYSTEM = 'SYSTEM'
-    '''SYSTEM'''
-    LIGHT = 'LIGHT'
-    '''LIGHT'''
-    DARK = 'DARK'
-    '''DARK'''
-    UNKNOWN = 'UNKNOWN'
-    '''UNKNOWN'''
-
-    def __reduce_ex__(self, proto):
-        return self.__class__, (self.name,)
-
-
-authentication_api_AppearanceSetting.__name__ = "AppearanceSetting"
-authentication_api_AppearanceSetting.__qualname__ = "AppearanceSetting"
-authentication_api_AppearanceSetting.__module__ = "nominal_api.authentication_api"
-
-
-class authentication_api_AuthenticationServiceV2(Service):
-    """
-    This service provides operations for managing user and org profiles/settings.
-Its name is a bit of a misnomer.
-    """
-
-    def get_my_profile(self, auth_header: str) -> "authentication_api_UserV2":
-        """
-        Gets the profile of the authenticated user.
-        """
-
-        _headers: Dict[str, Any] = {
-            'Accept': 'application/json',
-            'Authorization': auth_header,
-        }
-
-        _params: Dict[str, Any] = {
-        }
-
-        _path_params: Dict[str, Any] = {
-        }
-
-        _json: Any = None
-
-        _path = '/authentication/v2/my/profile'
-        _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(), authentication_api_UserV2, self._return_none_for_unknown_union_types)
-
-    def update_my_profile(self, auth_header: str, update_my_profile_request: "authentication_api_UpdateMyProfileRequest") -> "authentication_api_UserV2":
-        """
-        Updates the profile of the authenticated user.
-        """
-
-        _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(update_my_profile_request)
-
-        _path = '/authentication/v2/my/profile'
-        _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(), authentication_api_UserV2, self._return_none_for_unknown_union_types)
-
-    def get_my_settings(self, auth_header: str) -> "authentication_api_UserSettings":
-        """
-        Gets the settings of the authenticated user.
-        """
-
-        _headers: Dict[str, Any] = {
-            'Accept': 'application/json',
-            'Authorization': auth_header,
-        }
-
-        _params: Dict[str, Any] = {
-        }
-
-        _path_params: Dict[str, Any] = {
-        }
-
-        _json: Any = None
-
-        _path = '/authentication/v2/my/settings'
-        _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(), authentication_api_UserSettings, self._return_none_for_unknown_union_types)
-
-    def update_my_settings(self, auth_header: str, user_settings: "authentication_api_UserSettings") -> "authentication_api_UserSettings":
-        """
-        Updates the settings of the authenticated user.
-        """
-
-        _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(user_settings)
-
-        _path = '/authentication/v2/my/settings'
-        _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(), authentication_api_UserSettings, self._return_none_for_unknown_union_types)
-
-    def get_my_org_settings(self, auth_header: str) -> "authentication_api_OrgSettings":
-        """
-        Gets the settings of the org of the authenticated user.
-        """
-
-        _headers: Dict[str, Any] = {
-            'Accept': 'application/json',
-            'Authorization': auth_header,
-        }
-
-        _params: Dict[str, Any] = {
-        }
-
-        _path_params: Dict[str, Any] = {
-        }
-
-        _json: Any = None
-
-        _path = '/authentication/v2/org/settings'
-        _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(), authentication_api_OrgSettings, self._return_none_for_unknown_union_types)
-
-    def update_my_org_settings(self, auth_header: str, org_settings: "authentication_api_OrgSettings") -> "authentication_api_OrgSettings":
-        """
-        Updates the settings of the org of the authenticated user.
-        """
-
-        _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(org_settings)
-
-        _path = '/authentication/v2/org/settings'
-        _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(), authentication_api_OrgSettings, self._return_none_for_unknown_union_types)
-
-    def search_users_v2(self, auth_header: str, request: "authentication_api_SearchUsersRequest") -> "authentication_api_SearchUsersResponseV2":
-        """
-        Searches for users by email and displayName.
-        """
-
-        _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 = '/authentication/v2/users'
-        _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_SearchUsersResponseV2, self._return_none_for_unknown_union_types)
-
-    def get_users(self, auth_header: str, user_rids: List[str] = None) -> List["authentication_api_UserV2"]:
-        """
-        Get users by RID.
-        """
-        user_rids = user_rids if user_rids is not None else []
-
-        _headers: Dict[str, Any] = {
-            'Accept': 'application/json',
-            'Content-Type': 'application/json',
-            'Authorization': auth_header,
-        }
-
-        _params: Dict[str, Any] = {
-        }
-
-        _path_params: Dict[str, Any] = {
-        }
-
-        _json: Any = ConjureEncoder().default(user_rids)
-
-        _path = '/authentication/v2/users/batch'
-        _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[authentication_api_UserV2], self._return_none_for_unknown_union_types)
-
-    def get_user(self, auth_header: str, user_rid: str) -> "authentication_api_UserV2":
-        """
-        Gets a user by RID.
-        """
-
-        _headers: Dict[str, Any] = {
-            'Accept': 'application/json',
-            'Authorization': auth_header,
-        }
-
-        _params: Dict[str, Any] = {
-        }
-
-        _path_params: Dict[str, Any] = {
-            'userRid': user_rid,
-        }
-
-        _json: Any = None
-
-        _path = '/authentication/v2/users/{userRid}'
-        _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(), authentication_api_UserV2, self._return_none_for_unknown_union_types)
-
-
-authentication_api_AuthenticationServiceV2.__name__ = "AuthenticationServiceV2"
-authentication_api_AuthenticationServiceV2.__qualname__ = "AuthenticationServiceV2"
-authentication_api_AuthenticationServiceV2.__module__ = "nominal_api.authentication_api"
-
-
-class authentication_api_DefaultTimeRangeTypeSetting(ConjureEnumType):
-
-    DEFAULT = 'DEFAULT'
-    '''DEFAULT'''
-    ABSOLUTE = 'ABSOLUTE'
-    '''ABSOLUTE'''
-    RELATIVE = 'RELATIVE'
-    '''RELATIVE'''
-    UNKNOWN = 'UNKNOWN'
-    '''UNKNOWN'''
-
-    def __reduce_ex__(self, proto):
-        return self.__class__, (self.name,)
-
-
-authentication_api_DefaultTimeRangeTypeSetting.__name__ = "DefaultTimeRangeTypeSetting"
-authentication_api_DefaultTimeRangeTypeSetting.__qualname__ = "DefaultTimeRangeTypeSetting"
-authentication_api_DefaultTimeRangeTypeSetting.__module__ = "nominal_api.authentication_api"
-
-
-class authentication_api_OrgSettings(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'default_time_range_type': ConjureFieldDefinition('defaultTimeRangeType', OptionalTypeWrapper[authentication_api_DefaultTimeRangeTypeSetting])
-        }
-
-    __slots__: List[str] = ['_default_time_range_type']
-
-    def __init__(self, default_time_range_type: Optional["authentication_api_DefaultTimeRangeTypeSetting"] = None) -> None:
-        self._default_time_range_type = default_time_range_type
-
-    @builtins.property
-    def default_time_range_type(self) -> Optional["authentication_api_DefaultTimeRangeTypeSetting"]:
-        return self._default_time_range_type
-
-
-authentication_api_OrgSettings.__name__ = "OrgSettings"
-authentication_api_OrgSettings.__qualname__ = "OrgSettings"
-authentication_api_OrgSettings.__module__ = "nominal_api.authentication_api"
-
-
-class authentication_api_SearchUsersQuery(ConjureUnionType):
-    _and_: Optional[List["authentication_api_SearchUsersQuery"]] = None
-    _or_: Optional[List["authentication_api_SearchUsersQuery"]] = None
-    _exact_match: Optional[str] = None
-    _search_text: Optional[str] = None
-
-    @builtins.classmethod
-    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'and_': ConjureFieldDefinition('and', List[authentication_api_SearchUsersQuery]),
-            'or_': ConjureFieldDefinition('or', List[authentication_api_SearchUsersQuery]),
-            'exact_match': ConjureFieldDefinition('exactMatch', str),
-            'search_text': ConjureFieldDefinition('searchText', str)
-        }
-
-    def __init__(
-            self,
-            and_: Optional[List["authentication_api_SearchUsersQuery"]] = None,
-            or_: Optional[List["authentication_api_SearchUsersQuery"]] = None,
-            exact_match: Optional[str] = None,
-            search_text: Optional[str] = None,
-            type_of_union: Optional[str] = None
-            ) -> None:
-        if type_of_union is None:
-            if (and_ is not None) + (or_ is not None) + (exact_match is not None) + (search_text is not None) != 1:
-                raise ValueError('a union must contain a single member')
-
-            if and_ is not None:
-                self._and_ = and_
-                self._type = 'and'
-            if or_ is not None:
-                self._or_ = or_
-                self._type = 'or'
-            if exact_match is not None:
-                self._exact_match = exact_match
-                self._type = 'exactMatch'
-            if search_text is not None:
-                self._search_text = search_text
-                self._type = 'searchText'
-
-        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 == 'exactMatch':
-            if exact_match is None:
-                raise ValueError('a union value must not be None')
-            self._exact_match = exact_match
-            self._type = 'exactMatch'
-        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'
-
-    @builtins.property
-    def and_(self) -> Optional[List["authentication_api_SearchUsersQuery"]]:
-        return self._and_
-
-    @builtins.property
-    def or_(self) -> Optional[List["authentication_api_SearchUsersQuery"]]:
-        return self._or_
-
-    @builtins.property
-    def exact_match(self) -> Optional[str]:
-        """
-        Performs case insensitive exact match on email
-        """
-        return self._exact_match
-
-    @builtins.property
-    def search_text(self) -> Optional[str]:
-        """
-        Searches email and display name
-        """
-        return self._search_text
-
-    def accept(self, visitor) -> Any:
-        if not isinstance(visitor, authentication_api_SearchUsersQueryVisitor):
-            raise ValueError('{} is not an instance of authentication_api_SearchUsersQueryVisitor'.format(visitor.__class__.__name__))
-        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 == 'exactMatch' and self.exact_match is not None:
-            return visitor._exact_match(self.exact_match)
-        if self._type == 'searchText' and self.search_text is not None:
-            return visitor._search_text(self.search_text)
-
-
-authentication_api_SearchUsersQuery.__name__ = "SearchUsersQuery"
-authentication_api_SearchUsersQuery.__qualname__ = "SearchUsersQuery"
-authentication_api_SearchUsersQuery.__module__ = "nominal_api.authentication_api"
-
-
-class authentication_api_SearchUsersQueryVisitor:
-
-    @abstractmethod
-    def _and(self, and_: List["authentication_api_SearchUsersQuery"]) -> Any:
-        pass
-
-    @abstractmethod
-    def _or(self, or_: List["authentication_api_SearchUsersQuery"]) -> Any:
-        pass
-
-    @abstractmethod
-    def _exact_match(self, exact_match: str) -> Any:
-        pass
-
-    @abstractmethod
-    def _search_text(self, search_text: str) -> Any:
-        pass
-
-
-authentication_api_SearchUsersQueryVisitor.__name__ = "SearchUsersQueryVisitor"
-authentication_api_SearchUsersQueryVisitor.__qualname__ = "SearchUsersQueryVisitor"
-authentication_api_SearchUsersQueryVisitor.__module__ = "nominal_api.authentication_api"
-
-
-class authentication_api_SearchUsersRequest(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'query': ConjureFieldDefinition('query', authentication_api_SearchUsersQuery),
-            'sort_by': ConjureFieldDefinition('sortBy', OptionalTypeWrapper[authentication_api_SortBy]),
-            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token]),
-            'page_size': ConjureFieldDefinition('pageSize', OptionalTypeWrapper[int])
-        }
-
-    __slots__: List[str] = ['_query', '_sort_by', '_next_page_token', '_page_size']
-
-    def __init__(self, query: "authentication_api_SearchUsersQuery", next_page_token: Optional[str] = None, page_size: Optional[int] = None, sort_by: Optional["authentication_api_SortBy"] = None) -> None:
-        self._query = query
-        self._sort_by = sort_by
-        self._next_page_token = next_page_token
-        self._page_size = page_size
-
-    @builtins.property
-    def query(self) -> "authentication_api_SearchUsersQuery":
-        return self._query
-
-    @builtins.property
-    def sort_by(self) -> Optional["authentication_api_SortBy"]:
-        """
-        UPDATED_AT descending by default
-        """
-        return self._sort_by
-
-    @builtins.property
-    def next_page_token(self) -> Optional[str]:
-        return self._next_page_token
-
-    @builtins.property
-    def page_size(self) -> Optional[int]:
-        """
-        Defaults to 100. Will throw if larger than 1_000.
-        """
-        return self._page_size
-
-
-authentication_api_SearchUsersRequest.__name__ = "SearchUsersRequest"
-authentication_api_SearchUsersRequest.__qualname__ = "SearchUsersRequest"
-authentication_api_SearchUsersRequest.__module__ = "nominal_api.authentication_api"
-
-
-class authentication_api_SearchUsersResponseV2(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'results': ConjureFieldDefinition('results', List[authentication_api_UserV2]),
-            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token])
-        }
-
-    __slots__: List[str] = ['_results', '_next_page_token']
-
-    def __init__(self, results: List["authentication_api_UserV2"], next_page_token: Optional[str] = None) -> None:
-        self._results = results
-        self._next_page_token = next_page_token
-
-    @builtins.property
-    def results(self) -> List["authentication_api_UserV2"]:
-        return self._results
-
-    @builtins.property
-    def next_page_token(self) -> Optional[str]:
-        return self._next_page_token
-
-
-authentication_api_SearchUsersResponseV2.__name__ = "SearchUsersResponseV2"
-authentication_api_SearchUsersResponseV2.__qualname__ = "SearchUsersResponseV2"
-authentication_api_SearchUsersResponseV2.__module__ = "nominal_api.authentication_api"
-
-
-class authentication_api_SortBy(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'is_descending': ConjureFieldDefinition('isDescending', bool),
-            'field': ConjureFieldDefinition('field', authentication_api_SortByField)
-        }
-
-    __slots__: List[str] = ['_is_descending', '_field']
-
-    def __init__(self, field: "authentication_api_SortByField", is_descending: bool) -> None:
-        self._is_descending = is_descending
-        self._field = field
-
-    @builtins.property
-    def is_descending(self) -> bool:
-        return self._is_descending
-
-    @builtins.property
-    def field(self) -> "authentication_api_SortByField":
-        return self._field
-
-
-authentication_api_SortBy.__name__ = "SortBy"
-authentication_api_SortBy.__qualname__ = "SortBy"
-authentication_api_SortBy.__module__ = "nominal_api.authentication_api"
-
-
-class authentication_api_SortByField(ConjureEnumType):
-
-    NAME = 'NAME'
-    '''NAME'''
-    EMAIL = 'EMAIL'
-    '''EMAIL'''
-    CREATED_AT = 'CREATED_AT'
-    '''CREATED_AT'''
-    UPDATED_AT = 'UPDATED_AT'
-    '''UPDATED_AT'''
-    UNKNOWN = 'UNKNOWN'
-    '''UNKNOWN'''
-
-    def __reduce_ex__(self, proto):
-        return self.__class__, (self.name,)
-
-
-authentication_api_SortByField.__name__ = "SortByField"
-authentication_api_SortByField.__qualname__ = "SortByField"
-authentication_api_SortByField.__module__ = "nominal_api.authentication_api"
-
-
-class authentication_api_TimezoneSetting(ConjureEnumType):
-
-    LOCAL = 'LOCAL'
-    '''LOCAL'''
-    UTC = 'UTC'
-    '''UTC'''
-    UNKNOWN = 'UNKNOWN'
-    '''UNKNOWN'''
-
-    def __reduce_ex__(self, proto):
-        return self.__class__, (self.name,)
-
-
-authentication_api_TimezoneSetting.__name__ = "TimezoneSetting"
-authentication_api_TimezoneSetting.__qualname__ = "TimezoneSetting"
-authentication_api_TimezoneSetting.__module__ = "nominal_api.authentication_api"
-
-
-class authentication_api_UpdateMyProfileRequest(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'display_name': ConjureFieldDefinition('displayName', str)
-        }
-
-    __slots__: List[str] = ['_display_name']
-
-    def __init__(self, display_name: str) -> None:
-        self._display_name = display_name
-
-    @builtins.property
-    def display_name(self) -> str:
-        return self._display_name
-
-
-authentication_api_UpdateMyProfileRequest.__name__ = "UpdateMyProfileRequest"
-authentication_api_UpdateMyProfileRequest.__qualname__ = "UpdateMyProfileRequest"
-authentication_api_UpdateMyProfileRequest.__module__ = "nominal_api.authentication_api"
-
-
-class authentication_api_UserSettings(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'default_time_range_type': ConjureFieldDefinition('defaultTimeRangeType', OptionalTypeWrapper[authentication_api_DefaultTimeRangeTypeSetting]),
-            'appearance': ConjureFieldDefinition('appearance', OptionalTypeWrapper[authentication_api_AppearanceSetting]),
-            'timezone': ConjureFieldDefinition('timezone', OptionalTypeWrapper[authentication_api_TimezoneSetting]),
-            'time_series_hover_tooltip_concise': ConjureFieldDefinition('timeSeriesHoverTooltipConcise', OptionalTypeWrapper[bool])
-        }
-
-    __slots__: List[str] = ['_default_time_range_type', '_appearance', '_timezone', '_time_series_hover_tooltip_concise']
-
-    def __init__(self, appearance: Optional["authentication_api_AppearanceSetting"] = None, default_time_range_type: Optional["authentication_api_DefaultTimeRangeTypeSetting"] = None, time_series_hover_tooltip_concise: Optional[bool] = None, timezone: Optional["authentication_api_TimezoneSetting"] = None) -> None:
-        self._default_time_range_type = default_time_range_type
-        self._appearance = appearance
-        self._timezone = timezone
-        self._time_series_hover_tooltip_concise = time_series_hover_tooltip_concise
-
-    @builtins.property
-    def default_time_range_type(self) -> Optional["authentication_api_DefaultTimeRangeTypeSetting"]:
-        return self._default_time_range_type
-
-    @builtins.property
-    def appearance(self) -> Optional["authentication_api_AppearanceSetting"]:
-        return self._appearance
-
-    @builtins.property
-    def timezone(self) -> Optional["authentication_api_TimezoneSetting"]:
-        return self._timezone
-
-    @builtins.property
-    def time_series_hover_tooltip_concise(self) -> Optional[bool]:
-        return self._time_series_hover_tooltip_concise
-
-
-authentication_api_UserSettings.__name__ = "UserSettings"
-authentication_api_UserSettings.__qualname__ = "UserSettings"
-authentication_api_UserSettings.__module__ = "nominal_api.authentication_api"
-
-
-class authentication_api_UserV2(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'rid': ConjureFieldDefinition('rid', authentication_api_UserRid),
-            'org_rid': ConjureFieldDefinition('orgRid', authentication_api_OrgRid),
-            'email': ConjureFieldDefinition('email', str),
-            'display_name': ConjureFieldDefinition('displayName', str),
-            'avatar_url': ConjureFieldDefinition('avatarUrl', str)
-        }
-
-    __slots__: List[str] = ['_rid', '_org_rid', '_email', '_display_name', '_avatar_url']
-
-    def __init__(self, avatar_url: str, display_name: str, email: str, org_rid: str, rid: str) -> None:
-        self._rid = rid
-        self._org_rid = org_rid
-        self._email = email
-        self._display_name = display_name
-        self._avatar_url = avatar_url
-
-    @builtins.property
-    def rid(self) -> str:
-        return self._rid
-
-    @builtins.property
-    def org_rid(self) -> str:
-        return self._org_rid
-
-    @builtins.property
-    def email(self) -> str:
-        return self._email
-
-    @builtins.property
-    def display_name(self) -> str:
-        return self._display_name
-
-    @builtins.property
-    def avatar_url(self) -> str:
-        """
-        Avatar URL or a default avatar if the user does not have one.
-        """
-        return self._avatar_url
-
-
-authentication_api_UserV2.__name__ = "UserV2"
-authentication_api_UserV2.__qualname__ = "UserV2"
-authentication_api_UserV2.__module__ = "nominal_api.authentication_api"
-
-
-class authorization_ApiKey(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'rid': ConjureFieldDefinition('rid', authorization_ApiKeyRid),
-            'api_key_name': ConjureFieldDefinition('apiKeyName', str),
-            'created_by': ConjureFieldDefinition('createdBy', str),
-            'created_at': ConjureFieldDefinition('createdAt', str),
-            'expires_at': ConjureFieldDefinition('expiresAt', OptionalTypeWrapper[str]),
-            'is_deleted': ConjureFieldDefinition('isDeleted', bool)
-        }
-
-    __slots__: List[str] = ['_rid', '_api_key_name', '_created_by', '_created_at', '_expires_at', '_is_deleted']
-
-    def __init__(self, api_key_name: str, created_at: str, created_by: str, is_deleted: bool, rid: str, expires_at: Optional[str] = None) -> None:
-        self._rid = rid
-        self._api_key_name = api_key_name
-        self._created_by = created_by
-        self._created_at = created_at
-        self._expires_at = expires_at
-        self._is_deleted = is_deleted
-
-    @builtins.property
-    def rid(self) -> str:
-        return self._rid
-
-    @builtins.property
-    def api_key_name(self) -> str:
-        return self._api_key_name
-
-    @builtins.property
-    def created_by(self) -> str:
-        return self._created_by
-
-    @builtins.property
-    def created_at(self) -> str:
-        return self._created_at
-
-    @builtins.property
-    def expires_at(self) -> Optional[str]:
-        return self._expires_at
-
-    @builtins.property
-    def is_deleted(self) -> bool:
-        return self._is_deleted
-
-
-authorization_ApiKey.__name__ = "ApiKey"
-authorization_ApiKey.__qualname__ = "ApiKey"
-authorization_ApiKey.__module__ = "nominal_api.authorization"
-
-
-class authorization_AuthorizationRequest(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'rids': ConjureFieldDefinition('rids', List[str])
-        }
-
-    __slots__: List[str] = ['_rids']
-
-    def __init__(self, rids: List[str]) -> None:
-        self._rids = rids
-
-    @builtins.property
-    def rids(self) -> List[str]:
-        return self._rids
-
-
-authorization_AuthorizationRequest.__name__ = "AuthorizationRequest"
-authorization_AuthorizationRequest.__qualname__ = "AuthorizationRequest"
-authorization_AuthorizationRequest.__module__ = "nominal_api.authorization"
-
-
-class authorization_AuthorizationService(Service):
-    """
-    Authorization service manages the permissions for a user
-to access resources.
-    """
-
-    def authorize(self, auth_header: str, request: "authorization_AuthorizationRequest") -> List[str]:
-        """
-        Given a set of resources, returns the set of resources that the
-user is authorized to access.
-        """
-
-        _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 = '/authorization/v1/authorize'
-        _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[str], self._return_none_for_unknown_union_types)
-
-    def batch_get_workspace_for_resource(self, auth_header: str, request: List[str] = None) -> Dict[str, str]:
-        """
-        Given a set of resources, returns the workspace that each resource belongs to. If a user
-is not authorized on the resource, will omit the resource from the response.
-        """
-        request = request if request is not None else []
-
-        _headers: Dict[str, Any] = {
-            'Accept': 'application/json',
-            'Content-Type': 'application/json',
-            'Authorization': auth_header,
-        }
-
-        _params: Dict[str, Any] = {
-        }
-
-        _path_params: Dict[str, Any] = {
-        }
-
-        _json: Any = ConjureEncoder().default(request)
-
-        _path = '/authorization/v1/batch-get-workspace-for-resource'
-        _path = _path.format(**_path_params)
-
-        _response: Response = self._request(
-            'POST',
-            self._uri + _path,
-            params=_params,
-            headers=_headers,
-            json=_json)
-
-        _decoder = ConjureDecoder()
-        return _decoder.decode(_response.json(), Dict[str, api_rids_WorkspaceRid], self._return_none_for_unknown_union_types)
-
-    def register(self, auth_header: str, register_request: "authorization_RegistrationRequest") -> None:
-        """
-        Marks a resource as belonging to an organization.
-Will throw if trying to register a resource that already
-belongs to a different organization.
-        """
-
-        _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(register_request)
-
-        _path = '/authorization/v1/register'
-        _path = _path.format(**_path_params)
-
-        _response: Response = self._request(
-            'POST',
-            self._uri + _path,
-            params=_params,
-            headers=_headers,
-            json=_json)
-
-        return
-
-    def register_in_workspace(self, auth_header: str, request: "authorization_RegisterInWorkspaceRequest") -> None:
-        """
-        Marks a set of resources as belonging to a workspace. Either all resources are
-registered or none are.
-If the user is not in the workspace, this will throw.
-If a resource already belongs to a different workspace, this will throw.
-If a resource already belongs to this workspace, this is a no-op.
-        """
-
-        _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 = '/authorization/v1/register-in-workspace'
-        _path = _path.format(**_path_params)
-
-        _response: Response = self._request(
-            'POST',
-            self._uri + _path,
-            params=_params,
-            headers=_headers,
-            json=_json)
-
-        return
-
-    def check_admin(self, auth_header: str) -> None:
-        """
-        Given an authenticated session, this endpoint returns a HTTP 204 if the
-authenticated user is an admin and HTTP 403 otherwise.
-        """
-
-        _headers: Dict[str, Any] = {
-            'Accept': 'application/json',
-            'Authorization': auth_header,
-        }
-
-        _params: Dict[str, Any] = {
-        }
-
-        _path_params: Dict[str, Any] = {
-        }
-
-        _json: Any = None
-
-        _path = '/authorization/v1/checkAdmin'
-        _path = _path.format(**_path_params)
-
-        _response: Response = self._request(
-            'GET',
-            self._uri + _path,
-            params=_params,
-            headers=_headers,
-            json=_json)
-
-        return
-
-    def is_email_allowed(self, request: "authorization_IsEmailAllowedRequest") -> "authorization_IsEmailAllowedResponse":
-        """
-        Checks if the email is allowed to register.
-        """
-
-        _headers: Dict[str, Any] = {
-            'Accept': 'application/json',
-            'Content-Type': 'application/json',
-        }
-
-        _params: Dict[str, Any] = {
-        }
-
-        _path_params: Dict[str, Any] = {
-        }
-
-        _json: Any = ConjureEncoder().default(request)
-
-        _path = '/authorization/v1/is-email-allowed'
-        _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(), authorization_IsEmailAllowedResponse, self._return_none_for_unknown_union_types)
-
-    def get_access_token(self, request: "authorization_GetAccessTokenRequest") -> "authorization_GetAccessTokenResponse":
-        """
-        Provide an OIDC ID and access token to get a Nominal access token,
-suitable for making API requests. Its expiry will match that of the
-input access token, capped at 24h.
-Throws NotAuthorized if either token is invalid or if the OIDC provider
-is not known.
-        """
-
-        _headers: Dict[str, Any] = {
-            'Accept': 'application/json',
-            'Content-Type': 'application/json',
-        }
-
-        _params: Dict[str, Any] = {
-        }
-
-        _path_params: Dict[str, Any] = {
-        }
-
-        _json: Any = ConjureEncoder().default(request)
-
-        _path = '/authorization/v1/access-token'
-        _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(), authorization_GetAccessTokenResponse, self._return_none_for_unknown_union_types)
-
-    def create_api_key(self, auth_header: str, request: "authorization_CreateApiKeyRequest") -> "authorization_CreateApiKeyResponse":
-        """
-        Provide a long-lived API key for making API requests.
-The API key is irretrievable after initial creation.
-        """
-
-        _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 = '/authorization/v1/api-key'
-        _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(), authorization_CreateApiKeyResponse, self._return_none_for_unknown_union_types)
-
-    def list_api_keys_in_org(self, auth_header: str, request: "authorization_ListApiKeyRequest") -> "authorization_ListApiKeyResponse":
-        """
-        List all API keys in the organization.
-        """
-
-        _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 = '/authorization/v1/api-keys/org'
-        _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(), authorization_ListApiKeyResponse, self._return_none_for_unknown_union_types)
-
-    def list_user_api_keys(self, auth_header: str, request: "authorization_ListApiKeyRequest") -> "authorization_ListApiKeyResponse":
-        """
-        List all API keys for the user.
-        """
-
-        _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 = '/authorization/v1/api-keys/user'
-        _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(), authorization_ListApiKeyResponse, self._return_none_for_unknown_union_types)
-
-    def revoke_api_key(self, auth_header: str, rid: str) -> None:
-        """
-        Delete an API key.
-        """
-
-        _headers: Dict[str, Any] = {
-            'Accept': 'application/json',
-            'Authorization': auth_header,
-        }
-
-        _params: Dict[str, Any] = {
-        }
-
-        _path_params: Dict[str, Any] = {
-            'rid': rid,
-        }
-
-        _json: Any = None
-
-        _path = '/authorization/v1/api-key/{rid}/delete'
-        _path = _path.format(**_path_params)
-
-        _response: Response = self._request(
-            'PUT',
-            self._uri + _path,
-            params=_params,
-            headers=_headers,
-            json=_json)
-
-        return
-
-
-authorization_AuthorizationService.__name__ = "AuthorizationService"
-authorization_AuthorizationService.__qualname__ = "AuthorizationService"
-authorization_AuthorizationService.__module__ = "nominal_api.authorization"
-
-
-class authorization_CreateApiKeyRequest(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'api_key_name': ConjureFieldDefinition('apiKeyName', str),
-            'expires_after_days': ConjureFieldDefinition('expiresAfterDays', OptionalTypeWrapper[int])
-        }
-
-    __slots__: List[str] = ['_api_key_name', '_expires_after_days']
-
-    def __init__(self, api_key_name: str, expires_after_days: Optional[int] = None) -> None:
-        self._api_key_name = api_key_name
-        self._expires_after_days = expires_after_days
-
-    @builtins.property
-    def api_key_name(self) -> str:
-        """
-        The name of the API key to create.
-        """
-        return self._api_key_name
-
-    @builtins.property
-    def expires_after_days(self) -> Optional[int]:
-        """
-        The number of days after which the API key will expire.
-If omitted, the API key will not expire.
-        """
-        return self._expires_after_days
-
-
-authorization_CreateApiKeyRequest.__name__ = "CreateApiKeyRequest"
-authorization_CreateApiKeyRequest.__qualname__ = "CreateApiKeyRequest"
-authorization_CreateApiKeyRequest.__module__ = "nominal_api.authorization"
-
-
-class authorization_CreateApiKeyResponse(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'api_key_metadata': ConjureFieldDefinition('apiKeyMetadata', authorization_ApiKey),
-            'api_key_value': ConjureFieldDefinition('apiKeyValue', str)
-        }
-
-    __slots__: List[str] = ['_api_key_metadata', '_api_key_value']
-
-    def __init__(self, api_key_metadata: "authorization_ApiKey", api_key_value: str) -> None:
-        self._api_key_metadata = api_key_metadata
-        self._api_key_value = api_key_value
-
-    @builtins.property
-    def api_key_metadata(self) -> "authorization_ApiKey":
-        return self._api_key_metadata
-
-    @builtins.property
-    def api_key_value(self) -> str:
-        return self._api_key_value
-
-
-authorization_CreateApiKeyResponse.__name__ = "CreateApiKeyResponse"
-authorization_CreateApiKeyResponse.__qualname__ = "CreateApiKeyResponse"
-authorization_CreateApiKeyResponse.__module__ = "nominal_api.authorization"
-
-
-class authorization_GetAccessTokenFromApiKeyRequest(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'api_key_value': ConjureFieldDefinition('apiKeyValue', str)
-        }
-
-    __slots__: List[str] = ['_api_key_value']
-
-    def __init__(self, api_key_value: str) -> None:
-        self._api_key_value = api_key_value
-
-    @builtins.property
-    def api_key_value(self) -> str:
-        return self._api_key_value
-
-
-authorization_GetAccessTokenFromApiKeyRequest.__name__ = "GetAccessTokenFromApiKeyRequest"
-authorization_GetAccessTokenFromApiKeyRequest.__qualname__ = "GetAccessTokenFromApiKeyRequest"
-authorization_GetAccessTokenFromApiKeyRequest.__module__ = "nominal_api.authorization"
-
-
-class authorization_GetAccessTokenRequest(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'id_token': ConjureFieldDefinition('idToken', str),
-            'access_token': ConjureFieldDefinition('accessToken', str)
-        }
-
-    __slots__: List[str] = ['_id_token', '_access_token']
-
-    def __init__(self, access_token: str, id_token: str) -> None:
-        self._id_token = id_token
-        self._access_token = access_token
-
-    @builtins.property
-    def id_token(self) -> str:
-        return self._id_token
-
-    @builtins.property
-    def access_token(self) -> str:
-        """
-        The access token's audience must be for the Nominal API.
-        """
-        return self._access_token
-
-
-authorization_GetAccessTokenRequest.__name__ = "GetAccessTokenRequest"
-authorization_GetAccessTokenRequest.__qualname__ = "GetAccessTokenRequest"
-authorization_GetAccessTokenRequest.__module__ = "nominal_api.authorization"
-
-
-class authorization_GetAccessTokenResponse(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'access_token': ConjureFieldDefinition('accessToken', str),
-            'expires_at_seconds': ConjureFieldDefinition('expiresAtSeconds', int),
-            'user_uuid': ConjureFieldDefinition('userUuid', str),
-            'org_uuid': ConjureFieldDefinition('orgUuid', str)
-        }
-
-    __slots__: List[str] = ['_access_token', '_expires_at_seconds', '_user_uuid', '_org_uuid']
-
-    def __init__(self, access_token: str, expires_at_seconds: int, org_uuid: str, user_uuid: str) -> None:
-        self._access_token = access_token
-        self._expires_at_seconds = expires_at_seconds
-        self._user_uuid = user_uuid
-        self._org_uuid = org_uuid
-
-    @builtins.property
-    def access_token(self) -> str:
-        return self._access_token
-
-    @builtins.property
-    def expires_at_seconds(self) -> int:
-        return self._expires_at_seconds
-
-    @builtins.property
-    def user_uuid(self) -> str:
-        return self._user_uuid
-
-    @builtins.property
-    def org_uuid(self) -> str:
-        return self._org_uuid
-
-
-authorization_GetAccessTokenResponse.__name__ = "GetAccessTokenResponse"
-authorization_GetAccessTokenResponse.__qualname__ = "GetAccessTokenResponse"
-authorization_GetAccessTokenResponse.__module__ = "nominal_api.authorization"
-
-
-class authorization_InternalApiKeyService(Service):
-    """
-    This internal-only service manages long lived api keys.e
-    """
-
-    def get_access_token_from_api_key_value(self, request: "authorization_GetAccessTokenFromApiKeyRequest") -> "authorization_GetAccessTokenResponse":
-        """
-        Get a Nominal-issued access token from a long-lived API key. Callers should verify that
-their api key is formatted properly (i.e. prefixed with "nominal_api_key") before calling this endpoint.
-        """
-
-        _headers: Dict[str, Any] = {
-            'Accept': 'application/json',
-            'Content-Type': 'application/json',
-        }
-
-        _params: Dict[str, Any] = {
-        }
-
-        _path_params: Dict[str, Any] = {
-        }
-
-        _json: Any = ConjureEncoder().default(request)
-
-        _path = '/api-key-internal/v1/access-token'
-        _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(), authorization_GetAccessTokenResponse, self._return_none_for_unknown_union_types)
-
-
-authorization_InternalApiKeyService.__name__ = "InternalApiKeyService"
-authorization_InternalApiKeyService.__qualname__ = "InternalApiKeyService"
-authorization_InternalApiKeyService.__module__ = "nominal_api.authorization"
-
-
-class authorization_IsEmailAllowedRequest(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'email': ConjureFieldDefinition('email', str)
-        }
-
-    __slots__: List[str] = ['_email']
-
-    def __init__(self, email: str) -> None:
-        self._email = email
-
-    @builtins.property
-    def email(self) -> str:
-        return self._email
-
-
-authorization_IsEmailAllowedRequest.__name__ = "IsEmailAllowedRequest"
-authorization_IsEmailAllowedRequest.__qualname__ = "IsEmailAllowedRequest"
-authorization_IsEmailAllowedRequest.__module__ = "nominal_api.authorization"
-
-
-class authorization_IsEmailAllowedResponse(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'allowed': ConjureFieldDefinition('allowed', bool)
-        }
-
-    __slots__: List[str] = ['_allowed']
-
-    def __init__(self, allowed: bool) -> None:
-        self._allowed = allowed
-
-    @builtins.property
-    def allowed(self) -> bool:
-        return self._allowed
-
-
-authorization_IsEmailAllowedResponse.__name__ = "IsEmailAllowedResponse"
-authorization_IsEmailAllowedResponse.__qualname__ = "IsEmailAllowedResponse"
-authorization_IsEmailAllowedResponse.__module__ = "nominal_api.authorization"
-
-
-class authorization_ListApiKeyRequest(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'include_deleted': ConjureFieldDefinition('includeDeleted', OptionalTypeWrapper[bool]),
-            'include_expired': ConjureFieldDefinition('includeExpired', OptionalTypeWrapper[bool]),
-            'page_size': ConjureFieldDefinition('pageSize', OptionalTypeWrapper[int]),
-            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token])
-        }
-
-    __slots__: List[str] = ['_include_deleted', '_include_expired', '_page_size', '_next_page_token']
-
-    def __init__(self, include_deleted: Optional[bool] = None, include_expired: Optional[bool] = None, next_page_token: Optional[str] = None, page_size: Optional[int] = None) -> None:
-        self._include_deleted = include_deleted
-        self._include_expired = include_expired
-        self._page_size = page_size
-        self._next_page_token = next_page_token
-
-    @builtins.property
-    def include_deleted(self) -> Optional[bool]:
-        """
-        If true, include deleted API keys in the response. Defaults to false.
-        """
-        return self._include_deleted
-
-    @builtins.property
-    def include_expired(self) -> Optional[bool]:
-        """
-        If true, include expired API keys in the response. Defaults to false.
-        """
-        return self._include_expired
-
-    @builtins.property
-    def page_size(self) -> Optional[int]:
-        """
-        The maximum number of API keys to return. Defaults to 100.
-        """
-        return self._page_size
-
-    @builtins.property
-    def next_page_token(self) -> Optional[str]:
-        return self._next_page_token
-
-
-authorization_ListApiKeyRequest.__name__ = "ListApiKeyRequest"
-authorization_ListApiKeyRequest.__qualname__ = "ListApiKeyRequest"
-authorization_ListApiKeyRequest.__module__ = "nominal_api.authorization"
-
-
-class authorization_ListApiKeyResponse(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'api_keys': ConjureFieldDefinition('apiKeys', List[authorization_ApiKey]),
-            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token])
-        }
-
-    __slots__: List[str] = ['_api_keys', '_next_page_token']
-
-    def __init__(self, api_keys: List["authorization_ApiKey"], next_page_token: Optional[str] = None) -> None:
-        self._api_keys = api_keys
-        self._next_page_token = next_page_token
-
-    @builtins.property
-    def api_keys(self) -> List["authorization_ApiKey"]:
-        return self._api_keys
-
-    @builtins.property
-    def next_page_token(self) -> Optional[str]:
-        return self._next_page_token
-
-
-authorization_ListApiKeyResponse.__name__ = "ListApiKeyResponse"
-authorization_ListApiKeyResponse.__qualname__ = "ListApiKeyResponse"
-authorization_ListApiKeyResponse.__module__ = "nominal_api.authorization"
-
-
-class authorization_RegisterInWorkspaceRequest(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'resource_rids': ConjureFieldDefinition('resourceRids', List[str]),
-            'workspace_rid': ConjureFieldDefinition('workspaceRid', api_rids_WorkspaceRid)
-        }
-
-    __slots__: List[str] = ['_resource_rids', '_workspace_rid']
-
-    def __init__(self, resource_rids: List[str], workspace_rid: str) -> None:
-        self._resource_rids = resource_rids
-        self._workspace_rid = workspace_rid
-
-    @builtins.property
-    def resource_rids(self) -> List[str]:
-        return self._resource_rids
-
-    @builtins.property
-    def workspace_rid(self) -> str:
-        return self._workspace_rid
-
-
-authorization_RegisterInWorkspaceRequest.__name__ = "RegisterInWorkspaceRequest"
-authorization_RegisterInWorkspaceRequest.__qualname__ = "RegisterInWorkspaceRequest"
-authorization_RegisterInWorkspaceRequest.__module__ = "nominal_api.authorization"
-
-
-class authorization_RegistrationRequest(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'rids': ConjureFieldDefinition('rids', List[str]),
-            'organization_rid': ConjureFieldDefinition('organizationRid', OptionalTypeWrapper[str])
-        }
-
-    __slots__: List[str] = ['_rids', '_organization_rid']
-
-    def __init__(self, rids: List[str], organization_rid: Optional[str] = None) -> None:
-        self._rids = rids
-        self._organization_rid = organization_rid
-
-    @builtins.property
-    def rids(self) -> List[str]:
-        return self._rids
-
-    @builtins.property
-    def organization_rid(self) -> Optional[str]:
-        """
-        If omitted, will use the user's organizationRid.
-        """
-        return self._organization_rid
-
-
-authorization_RegistrationRequest.__name__ = "RegistrationRequest"
-authorization_RegistrationRequest.__qualname__ = "RegistrationRequest"
-authorization_RegistrationRequest.__module__ = "nominal_api.authorization"
-
-
 class comments_api_Comment(ConjureBeanType):
 
     @builtins.classmethod
@@ -4909,7 +3326,7 @@ class datasource_logset_api_CreateLogSetRequest(ConjureBeanType):
             'description': ConjureFieldDefinition('description', OptionalTypeWrapper[str]),
             'origin_metadata': ConjureFieldDefinition('originMetadata', Dict[str, str]),
             'timestamp_type': ConjureFieldDefinition('timestampType', datasource_TimestampType),
-            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_ids_WorkspaceId])
+            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_rids_WorkspaceRid])
         }
 
     __slots__: List[str] = ['_name', '_description', '_origin_metadata', '_timestamp_type', '_workspace']
@@ -5215,7 +3632,7 @@ class datasource_logset_api_SearchLogSetsRequest(ConjureBeanType):
         return {
             'token': ConjureFieldDefinition('token', OptionalTypeWrapper[api_Token]),
             'page_size': ConjureFieldDefinition('pageSize', OptionalTypeWrapper[int]),
-            'workspaces': ConjureFieldDefinition('workspaces', List[api_ids_WorkspaceId])
+            'workspaces': ConjureFieldDefinition('workspaces', List[api_rids_WorkspaceRid])
         }
 
     __slots__: List[str] = ['_token', '_page_size', '_workspaces']
@@ -6043,7 +4460,7 @@ class event_SearchQuery(ConjureUnionType):
             'property': ConjureFieldDefinition('property', api_Property),
             'and_': ConjureFieldDefinition('and', List[event_SearchQuery]),
             'or_': ConjureFieldDefinition('or', List[event_SearchQuery]),
-            'workspace': ConjureFieldDefinition('workspace', api_ids_WorkspaceId)
+            'workspace': ConjureFieldDefinition('workspace', api_rids_WorkspaceRid)
         }
 
     def __init__(
@@ -6995,7 +5412,7 @@ class ingest_api_DeprecatedTriggerIngest(ConjureBeanType):
             'properties': ConjureFieldDefinition('properties', Dict[str, str]),
             'dataset_name': ConjureFieldDefinition('datasetName', OptionalTypeWrapper[str]),
             'timestamp_metadata': ConjureFieldDefinition('timestampMetadata', OptionalTypeWrapper[ingest_api_DeprecatedTimestampMetadata]),
-            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_ids_WorkspaceId])
+            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_rids_WorkspaceRid])
         }
 
     __slots__: List[str] = ['_source', '_properties', '_dataset_name', '_timestamp_metadata', '_workspace']
@@ -7434,7 +5851,7 @@ class ingest_api_IngestMcapRequest(ConjureBeanType):
             'labels': ConjureFieldDefinition('labels', List[api_Label]),
             'title': ConjureFieldDefinition('title', OptionalTypeWrapper[str]),
             'description': ConjureFieldDefinition('description', OptionalTypeWrapper[str]),
-            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_ids_WorkspaceId])
+            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_rids_WorkspaceRid])
         }
 
     __slots__: List[str] = ['_sources', '_channel_config', '_channels', '_properties', '_labels', '_title', '_description', '_workspace']
@@ -7489,8 +5906,9 @@ channels with config, otherwise the mcap may not be supported.
     @builtins.property
     def workspace(self) -> Optional[str]:
         """
-        The workspace in which to create the dataset. If not provided, the dataset will be created in the default workspace for
-the user's organization, if the default workspace for the organization is configured.
+        The workspace in which to create the dataset or video. If not provided, the dataset or video
+will be created in the default workspace for the user's organization, if the default
+workspace for the organization is configured.
         """
         return self._workspace
 
@@ -7835,7 +6253,7 @@ class ingest_api_IngestRunRequest(ConjureBeanType):
             'labels': ConjureFieldDefinition('labels', List[api_Label]),
             'run_prefix': ConjureFieldDefinition('runPrefix', OptionalTypeWrapper[str]),
             'data_sources': ConjureFieldDefinition('dataSources', Dict[ingest_api_DataSourceRefName, ingest_api_IngestRunDataSource]),
-            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_ids_WorkspaceId])
+            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_rids_WorkspaceRid])
         }
 
     __slots__: List[str] = ['_rid', '_title', '_description', '_start_time', '_end_time', '_properties', '_labels', '_run_prefix', '_data_sources', '_workspace']
@@ -8326,18 +6744,20 @@ class ingest_api_IngestVideoRequest(ConjureBeanType):
             'labels': ConjureFieldDefinition('labels', List[api_Label]),
             'title': ConjureFieldDefinition('title', OptionalTypeWrapper[str]),
             'description': ConjureFieldDefinition('description', OptionalTypeWrapper[str]),
-            'timestamps': ConjureFieldDefinition('timestamps', ingest_api_VideoTimestampManifest)
+            'timestamps': ConjureFieldDefinition('timestamps', ingest_api_VideoTimestampManifest),
+            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_rids_WorkspaceRid])
         }
 
-    __slots__: List[str] = ['_sources', '_properties', '_labels', '_title', '_description', '_timestamps']
+    __slots__: List[str] = ['_sources', '_properties', '_labels', '_title', '_description', '_timestamps', '_workspace']
 
-    def __init__(self, labels: List[str], properties: Dict[str, str], sources: List["ingest_api_IngestSource"], timestamps: "ingest_api_VideoTimestampManifest", description: Optional[str] = None, title: Optional[str] = None) -> None:
+    def __init__(self, labels: List[str], properties: Dict[str, str], sources: List["ingest_api_IngestSource"], timestamps: "ingest_api_VideoTimestampManifest", description: Optional[str] = None, title: Optional[str] = None, workspace: Optional[str] = None) -> None:
         self._sources = sources
         self._properties = properties
         self._labels = labels
         self._title = title
         self._description = description
         self._timestamps = timestamps
+        self._workspace = workspace
 
     @builtins.property
     def sources(self) -> List["ingest_api_IngestSource"]:
@@ -8363,6 +6783,14 @@ class ingest_api_IngestVideoRequest(ConjureBeanType):
     def timestamps(self) -> "ingest_api_VideoTimestampManifest":
         return self._timestamps
 
+    @builtins.property
+    def workspace(self) -> Optional[str]:
+        """
+        The workspace in which to create the video. If not provided, the video will be created in the default workspace for
+the user's organization, if the default workspace for the organization is configured.
+        """
+        return self._workspace
+
 
 ingest_api_IngestVideoRequest.__name__ = "IngestVideoRequest"
 ingest_api_IngestVideoRequest.__qualname__ = "IngestVideoRequest"
@@ -8410,23 +6838,42 @@ class ingest_api_InitiateMultipartUploadRequest(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'filename': ConjureFieldDefinition('filename', str),
-            'filetype': ConjureFieldDefinition('filetype', str)
+            'filetype': ConjureFieldDefinition('filetype', str),
+            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_rids_WorkspaceRid])
         }
 
-    __slots__: List[str] = ['_filename', '_filetype']
+    __slots__: List[str] = ['_filename', '_filetype', '_workspace']
 
-    def __init__(self, filename: str, filetype: str) -> None:
+    def __init__(self, filename: str, filetype: str, workspace: Optional[str] = None) -> None:
         self._filename = filename
         self._filetype = filetype
+        self._workspace = workspace
 
     @builtins.property
     def filename(self) -> str:
+        """
+        The desired name of the file in object storage. The final name will be
+prefixed with a timestamp to ensure uniqueness.
+        """
         return self._filename
 
     @builtins.property
     def filetype(self) -> str:
+        """
+        The MIME type of the file, eg "text/csv" for CSVs or "application/octet-stream"
+for binary files.
+        """
         return self._filetype
 
+    @builtins.property
+    def workspace(self) -> Optional[str]:
+        """
+        The workspace in which to upload the file. If not provided, the file will be uploaded to
+the default workspace for the user's organization, if that is configured and the user
+has access to it.
+        """
+        return self._workspace
+
 
 ingest_api_InitiateMultipartUploadRequest.__name__ = "InitiateMultipartUploadRequest"
 ingest_api_InitiateMultipartUploadRequest.__qualname__ = "InitiateMultipartUploadRequest"
@@ -9127,7 +7574,7 @@ class ingest_api_NewDatasetIngestDestination(ConjureBeanType):
             'properties': ConjureFieldDefinition('properties', Dict[api_PropertyName, api_PropertyValue]),
             'labels': ConjureFieldDefinition('labels', List[api_Label]),
             'channel_config': ConjureFieldDefinition('channelConfig', OptionalTypeWrapper[ingest_api_ChannelConfig]),
-            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_ids_WorkspaceId])
+            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_rids_WorkspaceRid])
         }
 
     __slots__: List[str] = ['_dataset_name', '_dataset_description', '_properties', '_labels', '_channel_config', '_workspace']
@@ -9183,17 +7630,19 @@ class ingest_api_NewVideoIngestDestination(ConjureBeanType):
             'description': ConjureFieldDefinition('description', OptionalTypeWrapper[str]),
             'properties': ConjureFieldDefinition('properties', Dict[api_PropertyName, api_PropertyValue]),
             'labels': ConjureFieldDefinition('labels', List[api_Label]),
-            'video_file_details': ConjureFieldDefinition('videoFileDetails', OptionalTypeWrapper[ingest_api_VideoFileIngestDetails])
+            'video_file_details': ConjureFieldDefinition('videoFileDetails', OptionalTypeWrapper[ingest_api_VideoFileIngestDetails]),
+            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_rids_WorkspaceRid])
         }
 
-    __slots__: List[str] = ['_title', '_description', '_properties', '_labels', '_video_file_details']
+    __slots__: List[str] = ['_title', '_description', '_properties', '_labels', '_video_file_details', '_workspace']
 
-    def __init__(self, labels: List[str], properties: Dict[str, str], description: Optional[str] = None, title: Optional[str] = None, video_file_details: Optional["ingest_api_VideoFileIngestDetails"] = None) -> None:
+    def __init__(self, labels: List[str], properties: Dict[str, str], description: Optional[str] = None, title: Optional[str] = None, video_file_details: Optional["ingest_api_VideoFileIngestDetails"] = None, workspace: Optional[str] = None) -> None:
         self._title = title
         self._description = description
         self._properties = properties
         self._labels = labels
         self._video_file_details = video_file_details
+        self._workspace = workspace
 
     @builtins.property
     def title(self) -> Optional[str]:
@@ -9231,6 +7680,14 @@ If not provided, a name is deduced from the ingested file.
         """
         return self._video_file_details
 
+    @builtins.property
+    def workspace(self) -> Optional[str]:
+        """
+        The workspace in which to create the video. If not provided, the video will be created in the default workspace for
+the user's organization, if the default workspace for the organization is configured.
+        """
+        return self._workspace
+
 
 ingest_api_NewVideoIngestDestination.__name__ = "NewVideoIngestDestination"
 ingest_api_NewVideoIngestDestination.__qualname__ = "NewVideoIngestDestination"
@@ -9798,7 +8255,7 @@ class ingest_api_TriggerIngest(ConjureBeanType):
             'dataset_description': ConjureFieldDefinition('datasetDescription', OptionalTypeWrapper[str]),
             'timestamp_metadata': ConjureFieldDefinition('timestampMetadata', OptionalTypeWrapper[ingest_api_TimestampMetadata]),
             'channel_config': ConjureFieldDefinition('channelConfig', OptionalTypeWrapper[ingest_api_ChannelConfig]),
-            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_ids_WorkspaceId])
+            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_rids_WorkspaceRid])
         }
 
     __slots__: List[str] = ['_source', '_properties', '_labels', '_dataset_name', '_dataset_description', '_timestamp_metadata', '_channel_config', '_workspace']
@@ -10159,22 +8616,28 @@ ingest_api_VideoTimestampManifestVisitor.__module__ = "nominal_api.ingest_api"
 class persistent_compute_api_ClientMessage(ConjureUnionType):
     _subscribe: Optional[Dict[str, "persistent_compute_api_StreamingComputeNodeSubscription"]] = None
     _unsubscribe: Optional[List[str]] = None
+    _ping: Optional["persistent_compute_api_Ping"] = None
+    _pong: Optional["persistent_compute_api_Pong"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'subscribe': ConjureFieldDefinition('subscribe', Dict[persistent_compute_api_SubscriptionId, persistent_compute_api_StreamingComputeNodeSubscription]),
-            'unsubscribe': ConjureFieldDefinition('unsubscribe', List[persistent_compute_api_SubscriptionId])
+            'unsubscribe': ConjureFieldDefinition('unsubscribe', List[persistent_compute_api_SubscriptionId]),
+            'ping': ConjureFieldDefinition('ping', persistent_compute_api_Ping),
+            'pong': ConjureFieldDefinition('pong', persistent_compute_api_Pong)
         }
 
     def __init__(
             self,
             subscribe: Optional[Dict[str, "persistent_compute_api_StreamingComputeNodeSubscription"]] = None,
             unsubscribe: Optional[List[str]] = None,
+            ping: Optional["persistent_compute_api_Ping"] = None,
+            pong: Optional["persistent_compute_api_Pong"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (subscribe is not None) + (unsubscribe is not None) != 1:
+            if (subscribe is not None) + (unsubscribe is not None) + (ping is not None) + (pong is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if subscribe is not None:
@@ -10183,6 +8646,12 @@ class persistent_compute_api_ClientMessage(ConjureUnionType):
             if unsubscribe is not None:
                 self._unsubscribe = unsubscribe
                 self._type = 'unsubscribe'
+            if ping is not None:
+                self._ping = ping
+                self._type = 'ping'
+            if pong is not None:
+                self._pong = pong
+                self._type = 'pong'
 
         elif type_of_union == 'subscribe':
             if subscribe is None:
@@ -10194,6 +8663,16 @@ class persistent_compute_api_ClientMessage(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._unsubscribe = unsubscribe
             self._type = 'unsubscribe'
+        elif type_of_union == 'ping':
+            if ping is None:
+                raise ValueError('a union value must not be None')
+            self._ping = ping
+            self._type = 'ping'
+        elif type_of_union == 'pong':
+            if pong is None:
+                raise ValueError('a union value must not be None')
+            self._pong = pong
+            self._type = 'pong'
 
     @builtins.property
     def subscribe(self) -> Optional[Dict[str, "persistent_compute_api_StreamingComputeNodeSubscription"]]:
@@ -10210,6 +8689,14 @@ for the subscription will be sent periodically via `ServerMessage::subscriptionU
     def unsubscribe(self) -> Optional[List[str]]:
         return self._unsubscribe
 
+    @builtins.property
+    def ping(self) -> Optional["persistent_compute_api_Ping"]:
+        return self._ping
+
+    @builtins.property
+    def pong(self) -> Optional["persistent_compute_api_Pong"]:
+        return self._pong
+
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, persistent_compute_api_ClientMessageVisitor):
             raise ValueError('{} is not an instance of persistent_compute_api_ClientMessageVisitor'.format(visitor.__class__.__name__))
@@ -10217,6 +8704,10 @@ for the subscription will be sent periodically via `ServerMessage::subscriptionU
             return visitor._subscribe(self.subscribe)
         if self._type == 'unsubscribe' and self.unsubscribe is not None:
             return visitor._unsubscribe(self.unsubscribe)
+        if self._type == 'ping' and self.ping is not None:
+            return visitor._ping(self.ping)
+        if self._type == 'pong' and self.pong is not None:
+            return visitor._pong(self.pong)
 
 
 persistent_compute_api_ClientMessage.__name__ = "ClientMessage"
@@ -10234,6 +8725,14 @@ class persistent_compute_api_ClientMessageVisitor:
     def _unsubscribe(self, unsubscribe: List[str]) -> Any:
         pass
 
+    @abstractmethod
+    def _ping(self, ping: "persistent_compute_api_Ping") -> Any:
+        pass
+
+    @abstractmethod
+    def _pong(self, pong: "persistent_compute_api_Pong") -> Any:
+        pass
+
 
 persistent_compute_api_ClientMessageVisitor.__name__ = "ClientMessageVisitor"
 persistent_compute_api_ClientMessageVisitor.__qualname__ = "ClientMessageVisitor"
@@ -10269,25 +8768,89 @@ persistent_compute_api_FullResult.__qualname__ = "FullResult"
 persistent_compute_api_FullResult.__module__ = "nominal_api.persistent_compute_api"
 
 
+class persistent_compute_api_Ping(ConjureBeanType):
+    """
+    A ping can be sent by both client and server to keep the connection open and check that it is still working.
+The receiving end should send back a pong immediately.
+We also include the times that pings and pongs are sent so that we can track latency and/or discover clock
+drift between server and client.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'sent_at': ConjureFieldDefinition('sentAt', str)
+        }
+
+    __slots__: List[str] = ['_sent_at']
+
+    def __init__(self, sent_at: str) -> None:
+        self._sent_at = sent_at
+
+    @builtins.property
+    def sent_at(self) -> str:
+        return self._sent_at
+
+
+persistent_compute_api_Ping.__name__ = "Ping"
+persistent_compute_api_Ping.__qualname__ = "Ping"
+persistent_compute_api_Ping.__module__ = "nominal_api.persistent_compute_api"
+
+
+class persistent_compute_api_Pong(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'ping_originally_sent_at': ConjureFieldDefinition('pingOriginallySentAt', str),
+            'sent_at': ConjureFieldDefinition('sentAt', str)
+        }
+
+    __slots__: List[str] = ['_ping_originally_sent_at', '_sent_at']
+
+    def __init__(self, ping_originally_sent_at: str, sent_at: str) -> None:
+        self._ping_originally_sent_at = ping_originally_sent_at
+        self._sent_at = sent_at
+
+    @builtins.property
+    def ping_originally_sent_at(self) -> str:
+        return self._ping_originally_sent_at
+
+    @builtins.property
+    def sent_at(self) -> str:
+        return self._sent_at
+
+
+persistent_compute_api_Pong.__name__ = "Pong"
+persistent_compute_api_Pong.__qualname__ = "Pong"
+persistent_compute_api_Pong.__module__ = "nominal_api.persistent_compute_api"
+
+
 class persistent_compute_api_ServerMessage(ConjureUnionType):
     _subscription_update: Optional["persistent_compute_api_SubscriptionUpdate"] = None
     _subscription_error: Optional["persistent_compute_api_SubscriptionError"] = None
+    _ping: Optional["persistent_compute_api_Ping"] = None
+    _pong: Optional["persistent_compute_api_Pong"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'subscription_update': ConjureFieldDefinition('subscriptionUpdate', persistent_compute_api_SubscriptionUpdate),
-            'subscription_error': ConjureFieldDefinition('subscriptionError', persistent_compute_api_SubscriptionError)
+            'subscription_error': ConjureFieldDefinition('subscriptionError', persistent_compute_api_SubscriptionError),
+            'ping': ConjureFieldDefinition('ping', persistent_compute_api_Ping),
+            'pong': ConjureFieldDefinition('pong', persistent_compute_api_Pong)
         }
 
     def __init__(
             self,
             subscription_update: Optional["persistent_compute_api_SubscriptionUpdate"] = None,
             subscription_error: Optional["persistent_compute_api_SubscriptionError"] = None,
+            ping: Optional["persistent_compute_api_Ping"] = None,
+            pong: Optional["persistent_compute_api_Pong"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (subscription_update is not None) + (subscription_error is not None) != 1:
+            if (subscription_update is not None) + (subscription_error is not None) + (ping is not None) + (pong is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if subscription_update is not None:
@@ -10296,6 +8859,12 @@ class persistent_compute_api_ServerMessage(ConjureUnionType):
             if subscription_error is not None:
                 self._subscription_error = subscription_error
                 self._type = 'subscriptionError'
+            if ping is not None:
+                self._ping = ping
+                self._type = 'ping'
+            if pong is not None:
+                self._pong = pong
+                self._type = 'pong'
 
         elif type_of_union == 'subscriptionUpdate':
             if subscription_update is None:
@@ -10307,6 +8876,16 @@ class persistent_compute_api_ServerMessage(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._subscription_error = subscription_error
             self._type = 'subscriptionError'
+        elif type_of_union == 'ping':
+            if ping is None:
+                raise ValueError('a union value must not be None')
+            self._ping = ping
+            self._type = 'ping'
+        elif type_of_union == 'pong':
+            if pong is None:
+                raise ValueError('a union value must not be None')
+            self._pong = pong
+            self._type = 'pong'
 
     @builtins.property
     def subscription_update(self) -> Optional["persistent_compute_api_SubscriptionUpdate"]:
@@ -10316,6 +8895,14 @@ class persistent_compute_api_ServerMessage(ConjureUnionType):
     def subscription_error(self) -> Optional["persistent_compute_api_SubscriptionError"]:
         return self._subscription_error
 
+    @builtins.property
+    def ping(self) -> Optional["persistent_compute_api_Ping"]:
+        return self._ping
+
+    @builtins.property
+    def pong(self) -> Optional["persistent_compute_api_Pong"]:
+        return self._pong
+
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, persistent_compute_api_ServerMessageVisitor):
             raise ValueError('{} is not an instance of persistent_compute_api_ServerMessageVisitor'.format(visitor.__class__.__name__))
@@ -10323,6 +8910,10 @@ class persistent_compute_api_ServerMessage(ConjureUnionType):
             return visitor._subscription_update(self.subscription_update)
         if self._type == 'subscriptionError' and self.subscription_error is not None:
             return visitor._subscription_error(self.subscription_error)
+        if self._type == 'ping' and self.ping is not None:
+            return visitor._ping(self.ping)
+        if self._type == 'pong' and self.pong is not None:
+            return visitor._pong(self.pong)
 
 
 persistent_compute_api_ServerMessage.__name__ = "ServerMessage"
@@ -10340,6 +8931,14 @@ class persistent_compute_api_ServerMessageVisitor:
     def _subscription_error(self, subscription_error: "persistent_compute_api_SubscriptionError") -> Any:
         pass
 
+    @abstractmethod
+    def _ping(self, ping: "persistent_compute_api_Ping") -> Any:
+        pass
+
+    @abstractmethod
+    def _pong(self, pong: "persistent_compute_api_Pong") -> Any:
+        pass
+
 
 persistent_compute_api_ServerMessageVisitor.__name__ = "ServerMessageVisitor"
 persistent_compute_api_ServerMessageVisitor.__qualname__ = "ServerMessageVisitor"
@@ -13085,7 +11684,7 @@ class scout_asset_api_CreateAssetRequest(ConjureBeanType):
             'data_scopes': ConjureFieldDefinition('dataScopes', List[scout_asset_api_CreateAssetDataScope]),
             'attachments': ConjureFieldDefinition('attachments', List[api_rids_AttachmentRid]),
             'type': ConjureFieldDefinition('type', OptionalTypeWrapper[scout_rids_api_TypeRid]),
-            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_ids_WorkspaceId])
+            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_rids_WorkspaceRid])
         }
 
     __slots__: List[str] = ['_title', '_description', '_properties', '_labels', '_links', '_data_scopes', '_attachments', '_type', '_workspace']
@@ -13161,7 +11760,7 @@ class scout_asset_api_CreateTypeRequest(ConjureBeanType):
             'property_configs': ConjureFieldDefinition('propertyConfigs', Dict[api_PropertyName, scout_asset_api_PropertyConfig]),
             'description': ConjureFieldDefinition('description', OptionalTypeWrapper[str]),
             'icon_name': ConjureFieldDefinition('iconName', OptionalTypeWrapper[str]),
-            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_ids_WorkspaceId])
+            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_rids_WorkspaceRid])
         }
 
     __slots__: List[str] = ['_name', '_property_configs', '_description', '_icon_name', '_workspace']
@@ -13348,7 +11947,7 @@ class scout_asset_api_SearchAssetsQuery(ConjureUnionType):
             'and_': ConjureFieldDefinition('and', List[scout_asset_api_SearchAssetsQuery]),
             'or_': ConjureFieldDefinition('or', List[scout_asset_api_SearchAssetsQuery]),
             'is_staged': ConjureFieldDefinition('isStaged', bool),
-            'workspace': ConjureFieldDefinition('workspace', api_ids_WorkspaceId)
+            'workspace': ConjureFieldDefinition('workspace', api_rids_WorkspaceRid)
         }
 
     def __init__(
@@ -13627,7 +12226,7 @@ class scout_asset_api_SearchTypesQuery(ConjureUnionType):
             'property': ConjureFieldDefinition('property', api_PropertyName),
             'and_': ConjureFieldDefinition('and', List[scout_asset_api_SearchTypesQuery]),
             'or_': ConjureFieldDefinition('or', List[scout_asset_api_SearchTypesQuery]),
-            'workspace': ConjureFieldDefinition('workspace', api_ids_WorkspaceId)
+            'workspace': ConjureFieldDefinition('workspace', api_rids_WorkspaceRid)
         }
 
     def __init__(
@@ -15416,6 +14015,41 @@ a file, primarily CSV.
         _decoder = ConjureDecoder()
         return _decoder.decode(_response.json(), scout_catalog_EnrichedDataset, self._return_none_for_unknown_union_types)
 
+    def update_global_dataset_bounds(self, auth_header: str, request: "scout_catalog_UpdateBoundsRequest", rid: str) -> "scout_catalog_Dataset":
+        """
+        Update the bounds for a dataset without updating bounds of files within the dataset. If the
+current bounds of the dataset are not set, then the bounds of the request will be used. Otherwise,
+the bounds will be min(current start, request start), max(current end, request end).
+        """
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+            'rid': rid,
+        }
+
+        _json: Any = ConjureEncoder().default(request)
+
+        _path = '/catalog/v1/datasets/{rid}/bounds-from-streaming'
+        _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(), scout_catalog_Dataset, self._return_none_for_unknown_union_types)
+
     def delete_dataset_series(self, auth_header: str, dataset_rid: str) -> "scout_catalog_DeleteSeriesResult":
 
         _headers: Dict[str, Any] = {
@@ -15672,7 +14306,7 @@ class scout_catalog_CreateDataset(ConjureBeanType):
             'description': ConjureFieldDefinition('description', OptionalTypeWrapper[str]),
             'granularity': ConjureFieldDefinition('granularity', OptionalTypeWrapper[api_Granularity]),
             'is_v2_dataset': ConjureFieldDefinition('isV2Dataset', OptionalTypeWrapper[bool]),
-            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_ids_WorkspaceId])
+            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_rids_WorkspaceRid])
         }
 
     __slots__: List[str] = ['_name', '_handle', '_metadata', '_origin_metadata', '_labels', '_properties', '_description', '_granularity', '_is_v2_dataset', '_workspace']
@@ -15803,12 +14437,13 @@ class scout_catalog_Dataset(ConjureBeanType):
             'properties': ConjureFieldDefinition('properties', Dict[api_PropertyName, api_PropertyValue]),
             'labels': ConjureFieldDefinition('labels', List[api_Label]),
             'timestamp_type': ConjureFieldDefinition('timestampType', scout_catalog_WeakTimestampType),
-            'allow_streaming': ConjureFieldDefinition('allowStreaming', bool)
+            'allow_streaming': ConjureFieldDefinition('allowStreaming', bool),
+            'granularity': ConjureFieldDefinition('granularity', api_Granularity)
         }
 
-    __slots__: List[str] = ['_rid', '_name', '_handle', '_description', '_origin_metadata', '_bounds', '_properties', '_labels', '_timestamp_type', '_allow_streaming']
+    __slots__: List[str] = ['_rid', '_name', '_handle', '_description', '_origin_metadata', '_bounds', '_properties', '_labels', '_timestamp_type', '_allow_streaming', '_granularity']
 
-    def __init__(self, allow_streaming: bool, labels: List[str], name: str, origin_metadata: "scout_catalog_DatasetOriginMetadata", properties: Dict[str, str], rid: str, timestamp_type: "scout_catalog_WeakTimestampType", bounds: Optional["scout_catalog_Bounds"] = None, description: Optional[str] = None, handle: Optional["scout_catalog_Handle"] = None) -> None:
+    def __init__(self, allow_streaming: bool, granularity: "api_Granularity", labels: List[str], name: str, origin_metadata: "scout_catalog_DatasetOriginMetadata", properties: Dict[str, str], rid: str, timestamp_type: "scout_catalog_WeakTimestampType", bounds: Optional["scout_catalog_Bounds"] = None, description: Optional[str] = None, handle: Optional["scout_catalog_Handle"] = None) -> None:
         self._rid = rid
         self._name = name
         self._handle = handle
@@ -15819,6 +14454,7 @@ class scout_catalog_Dataset(ConjureBeanType):
         self._labels = labels
         self._timestamp_type = timestamp_type
         self._allow_streaming = allow_streaming
+        self._granularity = granularity
 
     @builtins.property
     def rid(self) -> str:
@@ -15860,6 +14496,10 @@ class scout_catalog_Dataset(ConjureBeanType):
     def allow_streaming(self) -> bool:
         return self._allow_streaming
 
+    @builtins.property
+    def granularity(self) -> "api_Granularity":
+        return self._granularity
+
 
 scout_catalog_Dataset.__name__ = "Dataset"
 scout_catalog_Dataset.__qualname__ = "Dataset"
@@ -16949,7 +15589,7 @@ class scout_catalog_SearchDatasetsQuery(ConjureUnionType):
             'archive_status': ConjureFieldDefinition('archiveStatus', bool),
             'and_': ConjureFieldDefinition('and', List[scout_catalog_SearchDatasetsQuery]),
             'or_': ConjureFieldDefinition('or', List[scout_catalog_SearchDatasetsQuery]),
-            'workspace': ConjureFieldDefinition('workspace', api_ids_WorkspaceId)
+            'workspace': ConjureFieldDefinition('workspace', api_rids_WorkspaceRid)
         }
 
     def __init__(
@@ -23020,15 +21660,15 @@ class scout_checklistexecution_api_ListStreamingChecklistRequest(ConjureBeanType
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'page_size': ConjureFieldDefinition('pageSize', OptionalTypeWrapper[int]),
-            'workspace_ids': ConjureFieldDefinition('workspaceIds', List[api_ids_WorkspaceId]),
+            'workspaces': ConjureFieldDefinition('workspaces', List[api_rids_WorkspaceRid]),
             'page_token': ConjureFieldDefinition('pageToken', OptionalTypeWrapper[str])
         }
 
-    __slots__: List[str] = ['_page_size', '_workspace_ids', '_page_token']
+    __slots__: List[str] = ['_page_size', '_workspaces', '_page_token']
 
-    def __init__(self, workspace_ids: List[str], page_size: Optional[int] = None, page_token: Optional[str] = None) -> None:
+    def __init__(self, workspaces: List[str], page_size: Optional[int] = None, page_token: Optional[str] = None) -> None:
         self._page_size = page_size
-        self._workspace_ids = workspace_ids
+        self._workspaces = workspaces
         self._page_token = page_token
 
     @builtins.property
@@ -23039,8 +21679,8 @@ class scout_checklistexecution_api_ListStreamingChecklistRequest(ConjureBeanType
         return self._page_size
 
     @builtins.property
-    def workspace_ids(self) -> List[str]:
-        return self._workspace_ids
+    def workspaces(self) -> List[str]:
+        return self._workspaces
 
     @builtins.property
     def page_token(self) -> Optional[str]:
@@ -23979,7 +22619,7 @@ class scout_checks_api_ChecklistSearchQuery(ConjureUnionType):
             'assignee_rid': ConjureFieldDefinition('assigneeRid', scout_rids_api_UserRid),
             'is_published': ConjureFieldDefinition('isPublished', bool),
             'not_': ConjureFieldDefinition('not', scout_checks_api_ChecklistSearchQuery),
-            'workspace': ConjureFieldDefinition('workspace', api_ids_WorkspaceId)
+            'workspace': ConjureFieldDefinition('workspace', api_rids_WorkspaceRid)
         }
 
     def __init__(
@@ -25014,7 +23654,7 @@ class scout_checks_api_CreateChecklistRequest(ConjureBeanType):
             'labels': ConjureFieldDefinition('labels', List[api_Label]),
             'checklist_variables': ConjureFieldDefinition('checklistVariables', List[scout_checks_api_UnresolvedChecklistVariable]),
             'is_published': ConjureFieldDefinition('isPublished', OptionalTypeWrapper[bool]),
-            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_ids_WorkspaceId])
+            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_rids_WorkspaceRid])
         }
 
     __slots__: List[str] = ['_commit_message', '_assignee_rid', '_title', '_description', '_functions', '_checks', '_properties', '_labels', '_checklist_variables', '_is_published', '_workspace']
@@ -54833,7 +53473,7 @@ class scout_datasource_connection_api_CreateConnection(ConjureBeanType):
             'scraping': ConjureFieldDefinition('scraping', OptionalTypeWrapper[scout_datasource_connection_api_ScrapingConfig]),
             'should_scrape': ConjureFieldDefinition('shouldScrape', bool),
             'limits': ConjureFieldDefinition('limits', OptionalTypeWrapper[scout_datasource_connection_api_LimitsConfig]),
-            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_ids_WorkspaceId])
+            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_rids_WorkspaceRid])
         }
 
     __slots__: List[str] = ['_name', '_description', '_connection_details', '_metadata', '_required_tag_names', '_available_tag_values', '_scraping', '_should_scrape', '_limits', '_workspace']
@@ -57035,7 +55675,7 @@ class scout_integrations_api_CreateIntegrationRequest(ConjureBeanType):
             'name': ConjureFieldDefinition('name', str),
             'description': ConjureFieldDefinition('description', OptionalTypeWrapper[str]),
             'create_integration_details': ConjureFieldDefinition('createIntegrationDetails', scout_integrations_api_CreateIntegrationDetails),
-            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_ids_WorkspaceId])
+            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_rids_WorkspaceRid])
         }
 
     __slots__: List[str] = ['_name', '_description', '_create_integration_details', '_workspace']
@@ -57949,7 +56589,7 @@ class scout_internal_search_api_SearchQuery(ConjureUnionType):
             'property': ConjureFieldDefinition('property', api_Property),
             'and_': ConjureFieldDefinition('and', List[scout_internal_search_api_SearchQuery]),
             'or_': ConjureFieldDefinition('or', List[scout_internal_search_api_SearchQuery]),
-            'workspace': ConjureFieldDefinition('workspace', api_ids_WorkspaceId)
+            'workspace': ConjureFieldDefinition('workspace', api_rids_WorkspaceRid)
         }
 
     def __init__(
@@ -59165,7 +57805,7 @@ class scout_metadata_ListPropertiesAndLabelsRequest(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'resource_types': ConjureFieldDefinition('resourceTypes', OptionalTypeWrapper[List[scout_metadata_ResourceType]]),
-            'workspaces': ConjureFieldDefinition('workspaces', OptionalTypeWrapper[List[api_ids_WorkspaceId]])
+            'workspaces': ConjureFieldDefinition('workspaces', OptionalTypeWrapper[List[api_rids_WorkspaceRid]])
         }
 
     __slots__: List[str] = ['_resource_types', '_workspaces']
@@ -59340,7 +57980,7 @@ class scout_notebook_api_CreateNotebookRequest(ConjureBeanType):
             'content_v2': ConjureFieldDefinition('contentV2', OptionalTypeWrapper[scout_workbookcommon_api_UnifiedWorkbookContent]),
             'event_refs': ConjureFieldDefinition('eventRefs', List[scout_workbookcommon_api_EventReference]),
             'check_alert_refs': ConjureFieldDefinition('checkAlertRefs', List[scout_workbookcommon_api_CheckAlertReference]),
-            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_ids_WorkspaceId])
+            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_rids_WorkspaceRid])
         }
 
     __slots__: List[str] = ['_title', '_description', '_notebook_type', '_is_draft', '_state_as_json', '_charts', '_run_rid', '_data_scope', '_layout', '_content', '_content_v2', '_event_refs', '_check_alert_refs', '_workspace']
@@ -59844,7 +58484,7 @@ class scout_notebook_api_SearchNotebooksQuery(ConjureUnionType):
             'notebook_type': ConjureFieldDefinition('notebookType', scout_notebook_api_NotebookType),
             'draft_state': ConjureFieldDefinition('draftState', bool),
             'archived': ConjureFieldDefinition('archived', bool),
-            'workspace': ConjureFieldDefinition('workspace', api_ids_WorkspaceId)
+            'workspace': ConjureFieldDefinition('workspace', api_rids_WorkspaceRid)
         }
 
     def __init__(
@@ -60823,7 +59463,7 @@ class scout_run_api_CreateRunRequest(ConjureBeanType):
             'attachments': ConjureFieldDefinition('attachments', List[api_rids_AttachmentRid]),
             'asset': ConjureFieldDefinition('asset', OptionalTypeWrapper[scout_rids_api_AssetRid]),
             'assets': ConjureFieldDefinition('assets', List[scout_rids_api_AssetRid]),
-            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_ids_WorkspaceId])
+            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_rids_WorkspaceRid])
         }
 
     __slots__: List[str] = ['_title', '_description', '_start_time', '_end_time', '_properties', '_labels', '_links', '_run_prefix', '_data_sources', '_attachments', '_asset', '_assets', '_workspace']
@@ -61254,7 +59894,7 @@ class scout_run_api_GetRunByIdRequest(ConjureBeanType):
         return {
             'run_number': ConjureFieldDefinition('runNumber', int),
             'run_prefix': ConjureFieldDefinition('runPrefix', OptionalTypeWrapper[str]),
-            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_ids_WorkspaceId])
+            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_rids_WorkspaceRid])
         }
 
     __slots__: List[str] = ['_run_number', '_run_prefix', '_workspace']
@@ -61768,7 +60408,7 @@ class scout_run_api_SearchQuery(ConjureUnionType):
             'check_alert_states_filter': ConjureFieldDefinition('checkAlertStatesFilter', scout_run_api_CheckAlertStatesFilter),
             'and_': ConjureFieldDefinition('and', List[scout_run_api_SearchQuery]),
             'or_': ConjureFieldDefinition('or', List[scout_run_api_SearchQuery]),
-            'workspace': ConjureFieldDefinition('workspace', api_ids_WorkspaceId)
+            'workspace': ConjureFieldDefinition('workspace', api_rids_WorkspaceRid)
         }
 
     def __init__(
@@ -62637,7 +61277,7 @@ class scout_template_api_CreateTemplateRequest(ConjureBeanType):
             'layout': ConjureFieldDefinition('layout', scout_layout_api_WorkbookLayout),
             'content': ConjureFieldDefinition('content', scout_workbookcommon_api_WorkbookContent),
             'message': ConjureFieldDefinition('message', str),
-            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_ids_WorkspaceId])
+            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_rids_WorkspaceRid])
         }
 
     __slots__: List[str] = ['_title', '_description', '_labels', '_properties', '_is_published', '_charts', '_layout', '_content', '_message', '_workspace']
@@ -62847,7 +61487,7 @@ class scout_template_api_SearchTemplatesQuery(ConjureUnionType):
             'created_by': ConjureFieldDefinition('createdBy', scout_rids_api_UserRid),
             'is_archived': ConjureFieldDefinition('isArchived', bool),
             'is_published': ConjureFieldDefinition('isPublished', bool),
-            'workspace': ConjureFieldDefinition('workspace', api_ids_WorkspaceId)
+            'workspace': ConjureFieldDefinition('workspace', api_rids_WorkspaceRid)
         }
 
     def __init__(
@@ -65332,7 +63972,7 @@ class scout_video_api_CreateVideoRequest(ConjureBeanType):
             'labels': ConjureFieldDefinition('labels', List[api_Label]),
             'properties': ConjureFieldDefinition('properties', Dict[api_PropertyName, api_PropertyValue]),
             'origin_metadata': ConjureFieldDefinition('originMetadata', OptionalTypeWrapper[scout_video_api_VideoOriginMetadata]),
-            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_ids_WorkspaceId])
+            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_rids_WorkspaceRid])
         }
 
     __slots__: List[str] = ['_title', '_description', '_labels', '_properties', '_origin_metadata', '_workspace']
@@ -66065,7 +64705,7 @@ class scout_video_api_SearchVideosQuery(ConjureUnionType):
             'and_': ConjureFieldDefinition('and', List[scout_video_api_SearchVideosQuery]),
             'or_': ConjureFieldDefinition('or', List[scout_video_api_SearchVideosQuery]),
             'ingest_status': ConjureFieldDefinition('ingestStatus', api_IngestStatus),
-            'workspace': ConjureFieldDefinition('workspace', api_ids_WorkspaceId)
+            'workspace': ConjureFieldDefinition('workspace', api_rids_WorkspaceRid)
         }
 
     def __init__(
@@ -67737,7 +66377,7 @@ class secrets_api_CreateSecretRequest(ConjureBeanType):
             'decrypted_value': ConjureFieldDefinition('decryptedValue', str),
             'properties': ConjureFieldDefinition('properties', Dict[api_PropertyName, api_PropertyValue]),
             'labels': ConjureFieldDefinition('labels', List[api_Label]),
-            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_ids_WorkspaceId])
+            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_rids_WorkspaceRid])
         }
 
     __slots__: List[str] = ['_name', '_description', '_decrypted_value', '_properties', '_labels', '_workspace']
@@ -67847,7 +66487,7 @@ class secrets_api_SearchSecretsQuery(ConjureUnionType):
             'property': ConjureFieldDefinition('property', api_Property),
             'and_': ConjureFieldDefinition('and', List[secrets_api_SearchSecretsQuery]),
             'or_': ConjureFieldDefinition('or', List[secrets_api_SearchSecretsQuery]),
-            'workspace': ConjureFieldDefinition('workspace', api_ids_WorkspaceId)
+            'workspace': ConjureFieldDefinition('workspace', api_rids_WorkspaceRid)
         }
 
     def __init__(
@@ -68491,87 +67131,6 @@ secrets_api_UpdateSecretRequest.__qualname__ = "UpdateSecretRequest"
 secrets_api_UpdateSecretRequest.__module__ = "nominal_api.secrets_api"
 
 
-class security_api_workspace_Workspace(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'id': ConjureFieldDefinition('id', api_ids_WorkspaceId),
-            'rid': ConjureFieldDefinition('rid', api_rids_WorkspaceRid),
-            'org': ConjureFieldDefinition('org', authentication_api_OrgRid)
-        }
-
-    __slots__: List[str] = ['_id', '_rid', '_org']
-
-    def __init__(self, id: str, org: str, rid: str) -> None:
-        self._id = id
-        self._rid = rid
-        self._org = org
-
-    @builtins.property
-    def id(self) -> str:
-        """
-        A unique identifier for the workspace within the organization. The workspace ID must be lower case alphanumeric characters, optionally separated by hyphens.
-        """
-        return self._id
-
-    @builtins.property
-    def rid(self) -> str:
-        return self._rid
-
-    @builtins.property
-    def org(self) -> str:
-        return self._org
-
-
-security_api_workspace_Workspace.__name__ = "Workspace"
-security_api_workspace_Workspace.__qualname__ = "Workspace"
-security_api_workspace_Workspace.__module__ = "nominal_api.security_api_workspace"
-
-
-class security_api_workspace_WorkspaceService(Service):
-    """
-    This service provides information about workspaces. Workspaces provide access control boundaries. All resources in
-Nominal live within a workspace.
-    """
-
-    def get_workspaces(self, auth_header: str) -> List["security_api_workspace_Workspace"]:
-        """
-        Gets all workspaces that the requesting user belongs to.
-        """
-
-        _headers: Dict[str, Any] = {
-            'Accept': 'application/json',
-            'Authorization': auth_header,
-        }
-
-        _params: Dict[str, Any] = {
-        }
-
-        _path_params: Dict[str, Any] = {
-        }
-
-        _json: Any = None
-
-        _path = '/workspaces/v1/workspaces'
-        _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(), List[security_api_workspace_Workspace], self._return_none_for_unknown_union_types)
-
-
-security_api_workspace_WorkspaceService.__name__ = "WorkspaceService"
-security_api_workspace_WorkspaceService.__qualname__ = "WorkspaceService"
-security_api_workspace_WorkspaceService.__module__ = "nominal_api.security_api_workspace"
-
-
 class storage_datasource_api_CreateNominalDataSourceRequest(ConjureBeanType):
 
     @builtins.classmethod
@@ -68581,7 +67140,7 @@ class storage_datasource_api_CreateNominalDataSourceRequest(ConjureBeanType):
             'description': ConjureFieldDefinition('description', OptionalTypeWrapper[str]),
             'granularity': ConjureFieldDefinition('granularity', OptionalTypeWrapper[api_Granularity]),
             'in_memory_streaming_enabled': ConjureFieldDefinition('inMemoryStreamingEnabled', OptionalTypeWrapper[bool]),
-            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_ids_WorkspaceId])
+            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_rids_WorkspaceRid])
         }
 
     __slots__: List[str] = ['_id', '_description', '_granularity', '_in_memory_streaming_enabled', '_workspace']
@@ -69801,7 +68360,7 @@ class storage_writer_api_WriteBatchesRequest(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'batches': ConjureFieldDefinition('batches', List[storage_writer_api_RecordsBatch]),
-            'data_source_rid': ConjureFieldDefinition('dataSourceRid', api_rids_NominalDataSourceRid),
+            'data_source_rid': ConjureFieldDefinition('dataSourceRid', api_rids_NominalDataSourceOrDatasetRid),
             'asynchronous_insert': ConjureFieldDefinition('asynchronousInsert', OptionalTypeWrapper[bool])
         }
 
@@ -69840,7 +68399,7 @@ class storage_writer_api_WriteBatchesRequestExternal(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'batches': ConjureFieldDefinition('batches', List[storage_writer_api_RecordsBatchExternal]),
-            'data_source_rid': ConjureFieldDefinition('dataSourceRid', api_rids_NominalDataSourceRid),
+            'data_source_rid': ConjureFieldDefinition('dataSourceRid', api_rids_NominalDataSourceOrDatasetRid),
             'asynchronous_insert': ConjureFieldDefinition('asynchronousInsert', OptionalTypeWrapper[bool])
         }
 
@@ -70263,7 +68822,7 @@ class themes_api_CreateChartThemeRequest(ConjureBeanType):
         return {
             'name': ConjureFieldDefinition('name', str),
             'content': ConjureFieldDefinition('content', themes_api_ChartThemeContent),
-            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_ids_WorkspaceId])
+            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_rids_WorkspaceRid])
         }
 
     __slots__: List[str] = ['_name', '_content', '_workspace']
@@ -74169,13 +72728,13 @@ timeseries_seriescache_api_S3Handle.__module__ = "nominal_api.timeseries_seriesc
 
 class upload_api_UploadService(Service):
     """
-    The Upload Service manages file uploads to S3.
+    The Upload Service manages file uploads to object storage.
     """
 
     def initiate_multipart_upload(self, auth_header: str, upload_request: "ingest_api_InitiateMultipartUploadRequest") -> "ingest_api_InitiateMultipartUploadResponse":
         """
-        Initiates a multipart upload to S3.
-Does not directly upload any parts, but returns an uploadId used to upload parts.
+        Initiates a multipart upload to object storage.
+Returns an uploadId that should be used with listParts, signPart, and completeMultipartUpload.
         """
 
         _headers: Dict[str, Any] = {
@@ -74275,7 +72834,8 @@ Returns a URL that will execute the upload without further authentication.
 
     def complete_multipart_upload(self, auth_header: str, key: str, upload_id: str, parts: List["ingest_api_Part"] = None) -> "ingest_api_CompleteMultipartUploadResponse":
         """
-        Completes a multipart upload to S3. This should be called after all parts have been uploaded.
+        Completes a multipart upload to object storage.
+This should be called after all parts have been uploaded.
         """
         parts = parts if parts is not None else []
 
@@ -74341,7 +72901,7 @@ Frees storage used by previously uploaded parts and prevents further uploads to
 
         return
 
-    def upload_file(self, auth_header: str, body: Any, file_name: str, size_bytes: Optional[int] = None) -> str:
+    def upload_file(self, auth_header: str, body: Any, file_name: str, size_bytes: Optional[int] = None, workspace: Optional[str] = None) -> str:
         """
         Uploads a file to S3. Intended for smaller files.
         """
@@ -74355,6 +72915,7 @@ Frees storage used by previously uploaded parts and prevents further uploads to
         _params: Dict[str, Any] = {
             'fileName': file_name,
             'sizeBytes': size_bytes,
+            'workspace': workspace,
         }
 
         _path_params: Dict[str, Any] = {
@@ -74431,8 +72992,6 @@ scout_channelvariables_api_ChannelVariableName = str
 
 scout_datareview_api_ManualCheckEvaluationRid = str
 
-api_ids_WorkspaceId = str
-
 scout_asset_api_Channel = str
 
 scout_rids_api_FunctionRid = str
@@ -74507,8 +73066,6 @@ storage_writer_api_Field = str
 
 api_TagName = str
 
-authentication_api_UserRid = str
-
 scout_datasource_connection_api_ConnectionRid = str
 
 scout_channelvariables_api_ComputeSpecV1 = str
@@ -74595,6 +73152,8 @@ scout_run_api_ConnectionRid = str
 
 timeseries_logicalseries_api_DatasetName = str
 
+api_rids_NominalDataSourceOrDatasetRid = str
+
 api_SeriesArchetypeRid = str
 
 scout_versioning_api_TagRid = str
@@ -74609,8 +73168,6 @@ scout_api_HexColor = str
 
 scout_datasource_connection_api_SecretRid = str
 
-authorization_ApiKeyRid = str
-
 scout_rids_api_ApiKeyRid = str
 
 ingest_api_ChannelPrefix = OptionalTypeWrapper[str]