nominal-api 0.603.0__py3-none-any.whl → 0.605.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']
@@ -7836,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']
@@ -8328,7 +6745,7 @@ class ingest_api_IngestVideoRequest(ConjureBeanType):
             'title': ConjureFieldDefinition('title', OptionalTypeWrapper[str]),
             'description': ConjureFieldDefinition('description', OptionalTypeWrapper[str]),
             'timestamps': ConjureFieldDefinition('timestamps', ingest_api_VideoTimestampManifest),
-            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_ids_WorkspaceId])
+            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_rids_WorkspaceRid])
         }
 
     __slots__: List[str] = ['_sources', '_properties', '_labels', '_title', '_description', '_timestamps', '_workspace']
@@ -8422,7 +6839,7 @@ class ingest_api_InitiateMultipartUploadRequest(ConjureBeanType):
         return {
             'filename': ConjureFieldDefinition('filename', str),
             'filetype': ConjureFieldDefinition('filetype', str),
-            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_ids_WorkspaceId])
+            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_rids_WorkspaceRid])
         }
 
     __slots__: List[str] = ['_filename', '_filetype', '_workspace']
@@ -9157,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']
@@ -9214,7 +7631,7 @@ class ingest_api_NewVideoIngestDestination(ConjureBeanType):
             'properties': ConjureFieldDefinition('properties', Dict[api_PropertyName, api_PropertyValue]),
             'labels': ConjureFieldDefinition('labels', List[api_Label]),
             'video_file_details': ConjureFieldDefinition('videoFileDetails', OptionalTypeWrapper[ingest_api_VideoFileIngestDetails]),
-            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_ids_WorkspaceId])
+            'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_rids_WorkspaceRid])
         }
 
     __slots__: List[str] = ['_title', '_description', '_properties', '_labels', '_video_file_details', '_workspace']
@@ -9838,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']
@@ -12270,7 +10687,8 @@ default, follow the UCUM convention for representation.
 
     def get_commensurable_units(self, auth_header: str, unit: str) -> List["scout_units_api_Unit"]:
         """
-        Returns the set of units that can be converted to and from the given unit.
+        Returns the set of cataloged units that can be converted to and from the given unit.
+No commensurable units does not imply the unit is invalid. Use /get-unit to check for validity.
         """
 
         _headers: Dict[str, Any] = {
@@ -13267,7 +11685,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']
@@ -13343,7 +11761,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']
@@ -13530,7 +11948,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__(
@@ -13809,7 +12227,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__(
@@ -15598,6 +14016,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] = {
@@ -15854,7 +14307,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']
@@ -15985,12 +14438,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
@@ -16001,6 +14455,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:
@@ -16042,6 +14497,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"
@@ -17131,7 +15590,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__(
@@ -23202,15 +21661,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
@@ -23221,8 +21680,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]:
@@ -24161,7 +22620,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__(
@@ -25196,7 +23655,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']
@@ -55015,7 +53474,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']
@@ -57217,7 +55676,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']
@@ -58131,7 +56590,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__(
@@ -59347,7 +57806,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']
@@ -59522,7 +57981,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']
@@ -60026,7 +58485,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__(
@@ -61005,7 +59464,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']
@@ -61436,7 +59895,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']
@@ -61950,7 +60409,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__(
@@ -62819,7 +61278,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']
@@ -63029,7 +61488,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__(
@@ -65514,7 +63973,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']
@@ -66247,7 +64706,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__(
@@ -67919,7 +66378,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']
@@ -68029,7 +66488,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__(
@@ -68673,87 +67132,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
@@ -68763,7 +67141,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']
@@ -69983,7 +68361,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])
         }
 
@@ -70022,7 +68400,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])
         }
 
@@ -70445,7 +68823,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']
@@ -74615,8 +72993,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
@@ -74691,8 +73067,6 @@ storage_writer_api_Field = str
 
 api_TagName = str
 
-authentication_api_UserRid = str
-
 scout_datasource_connection_api_ConnectionRid = str
 
 scout_channelvariables_api_ComputeSpecV1 = str
@@ -74779,6 +73153,8 @@ scout_run_api_ConnectionRid = str
 
 timeseries_logicalseries_api_DatasetName = str
 
+api_rids_NominalDataSourceOrDatasetRid = str
+
 api_SeriesArchetypeRid = str
 
 scout_versioning_api_TagRid = str
@@ -74793,8 +73169,6 @@ scout_api_HexColor = str
 
 scout_datasource_connection_api_SecretRid = str
 
-authorization_ApiKeyRid = str
-
 scout_rids_api_ApiKeyRid = str
 
 ingest_api_ChannelPrefix = OptionalTypeWrapper[str]