nominal-api 0.605.0__py3-none-any.whl → 0.606.1__py3-none-any.whl

nominal_api/_impl.py

@@ -1240,6 +1240,1589 @@ 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
@@ -16645,6 +18228,162 @@ scout_chartdefinition_api_AxisThresholdVisualization.__qualname__ = "AxisThresho
 scout_chartdefinition_api_AxisThresholdVisualization.__module__ = "nominal_api.scout_chartdefinition_api"
 
 
+class scout_chartdefinition_api_BitFlag(ConjureBeanType):
+    """
+    The settings for a bit flag mapping. Each position should be unique. Position 0 represents the least significant bit 
+and position 31 represents the most significant bit.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'position': ConjureFieldDefinition('position', int),
+            'label': ConjureFieldDefinition('label', str)
+        }
+
+    __slots__: List[str] = ['_position', '_label']
+
+    def __init__(self, label: str, position: int) -> None:
+        self._position = position
+        self._label = label
+
+    @builtins.property
+    def position(self) -> int:
+        return self._position
+
+    @builtins.property
+    def label(self) -> str:
+        return self._label
+
+
+scout_chartdefinition_api_BitFlag.__name__ = "BitFlag"
+scout_chartdefinition_api_BitFlag.__qualname__ = "BitFlag"
+scout_chartdefinition_api_BitFlag.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
+class scout_chartdefinition_api_BitFlagMapCellConfig(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'visualisation': ConjureFieldDefinition('visualisation', OptionalTypeWrapper[scout_chartdefinition_api_BitFlagMapVisualisation])
+        }
+
+    __slots__: List[str] = ['_visualisation']
+
+    def __init__(self, visualisation: Optional["scout_chartdefinition_api_BitFlagMapVisualisation"] = None) -> None:
+        self._visualisation = visualisation
+
+    @builtins.property
+    def visualisation(self) -> Optional["scout_chartdefinition_api_BitFlagMapVisualisation"]:
+        return self._visualisation
+
+
+scout_chartdefinition_api_BitFlagMapCellConfig.__name__ = "BitFlagMapCellConfig"
+scout_chartdefinition_api_BitFlagMapCellConfig.__qualname__ = "BitFlagMapCellConfig"
+scout_chartdefinition_api_BitFlagMapCellConfig.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
+class scout_chartdefinition_api_BitFlagMapRawVisualisation(ConjureBeanType):
+    """
+    The settings for a raw bit flag map visualisation.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'high_color': ConjureFieldDefinition('highColor', OptionalTypeWrapper[scout_api_HexColor]),
+            'low_color': ConjureFieldDefinition('lowColor', OptionalTypeWrapper[scout_api_HexColor]),
+            'bit_flags': ConjureFieldDefinition('bitFlags', List[scout_chartdefinition_api_BitFlag])
+        }
+
+    __slots__: List[str] = ['_high_color', '_low_color', '_bit_flags']
+
+    def __init__(self, bit_flags: List["scout_chartdefinition_api_BitFlag"], high_color: Optional[str] = None, low_color: Optional[str] = None) -> None:
+        self._high_color = high_color
+        self._low_color = low_color
+        self._bit_flags = bit_flags
+
+    @builtins.property
+    def high_color(self) -> Optional[str]:
+        """
+        The color when any bit is high
+        """
+        return self._high_color
+
+    @builtins.property
+    def low_color(self) -> Optional[str]:
+        """
+        The color when all bits are low
+        """
+        return self._low_color
+
+    @builtins.property
+    def bit_flags(self) -> List["scout_chartdefinition_api_BitFlag"]:
+        return self._bit_flags
+
+
+scout_chartdefinition_api_BitFlagMapRawVisualisation.__name__ = "BitFlagMapRawVisualisation"
+scout_chartdefinition_api_BitFlagMapRawVisualisation.__qualname__ = "BitFlagMapRawVisualisation"
+scout_chartdefinition_api_BitFlagMapRawVisualisation.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
+class scout_chartdefinition_api_BitFlagMapVisualisation(ConjureUnionType):
+    _raw: Optional["scout_chartdefinition_api_BitFlagMapRawVisualisation"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'raw': ConjureFieldDefinition('raw', scout_chartdefinition_api_BitFlagMapRawVisualisation)
+        }
+
+    def __init__(
+            self,
+            raw: Optional["scout_chartdefinition_api_BitFlagMapRawVisualisation"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (raw is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if raw is not None:
+                self._raw = raw
+                self._type = 'raw'
+
+        elif type_of_union == 'raw':
+            if raw is None:
+                raise ValueError('a union value must not be None')
+            self._raw = raw
+            self._type = 'raw'
+
+    @builtins.property
+    def raw(self) -> Optional["scout_chartdefinition_api_BitFlagMapRawVisualisation"]:
+        return self._raw
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_chartdefinition_api_BitFlagMapVisualisationVisitor):
+            raise ValueError('{} is not an instance of scout_chartdefinition_api_BitFlagMapVisualisationVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'raw' and self.raw is not None:
+            return visitor._raw(self.raw)
+
+
+scout_chartdefinition_api_BitFlagMapVisualisation.__name__ = "BitFlagMapVisualisation"
+scout_chartdefinition_api_BitFlagMapVisualisation.__qualname__ = "BitFlagMapVisualisation"
+scout_chartdefinition_api_BitFlagMapVisualisation.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
+class scout_chartdefinition_api_BitFlagMapVisualisationVisitor:
+
+    @abstractmethod
+    def _raw(self, raw: "scout_chartdefinition_api_BitFlagMapRawVisualisation") -> Any:
+        pass
+
+
+scout_chartdefinition_api_BitFlagMapVisualisationVisitor.__name__ = "BitFlagMapVisualisationVisitor"
+scout_chartdefinition_api_BitFlagMapVisualisationVisitor.__qualname__ = "BitFlagMapVisualisationVisitor"
+scout_chartdefinition_api_BitFlagMapVisualisationVisitor.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
 class scout_chartdefinition_api_CartesianChartDefinition(ConjureUnionType):
     _v1: Optional["scout_chartdefinition_api_CartesianChartDefinitionV1"] = None
 
@@ -19413,13 +21152,15 @@ class scout_chartdefinition_api_ValueTableCellConfig(ConjureUnionType):
     _numeric: Optional["scout_chartdefinition_api_NumericCellConfig"] = None
     _enum: Optional["scout_chartdefinition_api_EnumCellConfig"] = None
     _range: Optional["scout_chartdefinition_api_RangeCellConfig"] = None
+    _bit_flag_map: Optional["scout_chartdefinition_api_BitFlagMapCellConfig"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'numeric': ConjureFieldDefinition('numeric', scout_chartdefinition_api_NumericCellConfig),
             'enum': ConjureFieldDefinition('enum', scout_chartdefinition_api_EnumCellConfig),
-            'range': ConjureFieldDefinition('range', scout_chartdefinition_api_RangeCellConfig)
+            'range': ConjureFieldDefinition('range', scout_chartdefinition_api_RangeCellConfig),
+            'bit_flag_map': ConjureFieldDefinition('bitFlagMap', scout_chartdefinition_api_BitFlagMapCellConfig)
         }
 
     def __init__(
@@ -19427,10 +21168,11 @@ class scout_chartdefinition_api_ValueTableCellConfig(ConjureUnionType):
             numeric: Optional["scout_chartdefinition_api_NumericCellConfig"] = None,
             enum: Optional["scout_chartdefinition_api_EnumCellConfig"] = None,
             range: Optional["scout_chartdefinition_api_RangeCellConfig"] = None,
+            bit_flag_map: Optional["scout_chartdefinition_api_BitFlagMapCellConfig"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (numeric is not None) + (enum is not None) + (range is not None) != 1:
+            if (numeric is not None) + (enum is not None) + (range is not None) + (bit_flag_map is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if numeric is not None:
@@ -19442,6 +21184,9 @@ class scout_chartdefinition_api_ValueTableCellConfig(ConjureUnionType):
             if range is not None:
                 self._range = range
                 self._type = 'range'
+            if bit_flag_map is not None:
+                self._bit_flag_map = bit_flag_map
+                self._type = 'bitFlagMap'
 
         elif type_of_union == 'numeric':
             if numeric is None:
@@ -19458,6 +21203,11 @@ class scout_chartdefinition_api_ValueTableCellConfig(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._range = range
             self._type = 'range'
+        elif type_of_union == 'bitFlagMap':
+            if bit_flag_map is None:
+                raise ValueError('a union value must not be None')
+            self._bit_flag_map = bit_flag_map
+            self._type = 'bitFlagMap'
 
     @builtins.property
     def numeric(self) -> Optional["scout_chartdefinition_api_NumericCellConfig"]:
@@ -19471,6 +21221,10 @@ class scout_chartdefinition_api_ValueTableCellConfig(ConjureUnionType):
     def range(self) -> Optional["scout_chartdefinition_api_RangeCellConfig"]:
         return self._range
 
+    @builtins.property
+    def bit_flag_map(self) -> Optional["scout_chartdefinition_api_BitFlagMapCellConfig"]:
+        return self._bit_flag_map
+
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, scout_chartdefinition_api_ValueTableCellConfigVisitor):
             raise ValueError('{} is not an instance of scout_chartdefinition_api_ValueTableCellConfigVisitor'.format(visitor.__class__.__name__))
@@ -19480,6 +21234,8 @@ class scout_chartdefinition_api_ValueTableCellConfig(ConjureUnionType):
             return visitor._enum(self.enum)
         if self._type == 'range' and self.range is not None:
             return visitor._range(self.range)
+        if self._type == 'bitFlagMap' and self.bit_flag_map is not None:
+            return visitor._bit_flag_map(self.bit_flag_map)
 
 
 scout_chartdefinition_api_ValueTableCellConfig.__name__ = "ValueTableCellConfig"
@@ -19501,6 +21257,10 @@ class scout_chartdefinition_api_ValueTableCellConfigVisitor:
     def _range(self, range: "scout_chartdefinition_api_RangeCellConfig") -> Any:
         pass
 
+    @abstractmethod
+    def _bit_flag_map(self, bit_flag_map: "scout_chartdefinition_api_BitFlagMapCellConfig") -> Any:
+        pass
+
 
 scout_chartdefinition_api_ValueTableCellConfigVisitor.__name__ = "ValueTableCellConfigVisitor"
 scout_chartdefinition_api_ValueTableCellConfigVisitor.__qualname__ = "ValueTableCellConfigVisitor"
@@ -67132,6 +68892,151 @@ 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)
+
+    def get_workspace(self, auth_header: str, workspace_rid: str) -> "security_api_workspace_Workspace":
+        """
+        Gets the workspace with the specified WorkspaceRid.
+        """
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+            'workspaceRid': workspace_rid,
+        }
+
+        _json: Any = None
+
+        _path = '/workspaces/v1/workspaces/{workspaceRid}'
+        _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(), security_api_workspace_Workspace, self._return_none_for_unknown_union_types)
+
+    def get_default_workspace(self, auth_header: str) -> Optional["security_api_workspace_Workspace"]:
+        """
+        Gets the default workspace for the requesting user. It may not be present if the user does not have
+access to any workspaces or no default workspace is configured for the user's organization.
+        """
+
+        _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/default-workspace'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'GET',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        _decoder = ConjureDecoder()
+        return None if _response.status_code == 204 else _decoder.decode(_response.json(), OptionalTypeWrapper[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
@@ -72993,6 +74898,8 @@ scout_channelvariables_api_ChannelVariableName = str
 
 scout_datareview_api_ManualCheckEvaluationRid = str
 
+api_ids_WorkspaceId = str
+
 scout_asset_api_Channel = str
 
 scout_rids_api_FunctionRid = str
@@ -73067,6 +74974,8 @@ storage_writer_api_Field = str
 
 api_TagName = str
 
+authentication_api_UserRid = str
+
 scout_datasource_connection_api_ConnectionRid = str
 
 scout_channelvariables_api_ComputeSpecV1 = str
@@ -73169,6 +75078,8 @@ scout_api_HexColor = str
 
 scout_datasource_connection_api_SecretRid = str
 
+authorization_ApiKeyRid = str
+
 scout_rids_api_ApiKeyRid = str
 
 ingest_api_ChannelPrefix = OptionalTypeWrapper[str]