nominal-api 0.606.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
@@ -67309,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
@@ -73170,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
@@ -73244,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
@@ -73346,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]