# coding: utf-8 """ Hatchet API The Hatchet API The version of the OpenAPI document: 1.0.0 Generated by OpenAPI Generator (https://openapi-generator.tech) Do not edit the class manually. """ # noqa: E501 import warnings from typing import Any, Dict, List, Optional, Tuple, Union from pydantic import Field, StrictFloat, StrictInt, StrictStr, validate_call from typing_extensions import Annotated from hatchet_sdk.clients.rest.api_client import ApiClient, RequestSerialized from hatchet_sdk.clients.rest.api_response import ApiResponse from hatchet_sdk.clients.rest.models.accept_invite_request import AcceptInviteRequest from hatchet_sdk.clients.rest.models.create_tenant_alert_email_group_request import ( CreateTenantAlertEmailGroupRequest, ) from hatchet_sdk.clients.rest.models.create_tenant_invite_request import ( CreateTenantInviteRequest, ) from hatchet_sdk.clients.rest.models.create_tenant_request import CreateTenantRequest from hatchet_sdk.clients.rest.models.reject_invite_request import RejectInviteRequest from hatchet_sdk.clients.rest.models.tenant import Tenant from hatchet_sdk.clients.rest.models.tenant_alert_email_group import ( TenantAlertEmailGroup, ) from hatchet_sdk.clients.rest.models.tenant_alert_email_group_list import ( TenantAlertEmailGroupList, ) from hatchet_sdk.clients.rest.models.tenant_alerting_settings import ( TenantAlertingSettings, ) from hatchet_sdk.clients.rest.models.tenant_invite import TenantInvite from hatchet_sdk.clients.rest.models.tenant_invite_list import TenantInviteList from hatchet_sdk.clients.rest.models.tenant_member import TenantMember from hatchet_sdk.clients.rest.models.tenant_member_list import TenantMemberList from hatchet_sdk.clients.rest.models.tenant_resource_policy import TenantResourcePolicy from hatchet_sdk.clients.rest.models.tenant_step_run_queue_metrics import ( TenantStepRunQueueMetrics, ) from hatchet_sdk.clients.rest.models.update_tenant_alert_email_group_request import ( UpdateTenantAlertEmailGroupRequest, ) from hatchet_sdk.clients.rest.models.update_tenant_request import UpdateTenantRequest from hatchet_sdk.clients.rest.rest import RESTResponseType class TenantApi: """NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech Do not edit the class manually. """ def __init__(self, api_client=None) -> None: if api_client is None: api_client = ApiClient.get_default() self.api_client = api_client @validate_call async def alert_email_group_create( self, tenant: Annotated[ str, Field( min_length=36, strict=True, max_length=36, description="The tenant id" ), ], create_tenant_alert_email_group_request: Annotated[ CreateTenantAlertEmailGroupRequest, Field(description="The tenant alert email group to create"), ], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ], ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> TenantAlertEmailGroup: """Create tenant alert email group Creates a new tenant alert email group :param tenant: The tenant id (required) :type tenant: str :param create_tenant_alert_email_group_request: The tenant alert email group to create (required) :type create_tenant_alert_email_group_request: CreateTenantAlertEmailGroupRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._alert_email_group_create_serialize( tenant=tenant, create_tenant_alert_email_group_request=create_tenant_alert_email_group_request, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index, ) _response_types_map: Dict[str, Optional[str]] = { "201": "TenantAlertEmailGroup", "400": "APIErrors", "403": "APIError", } response_data = await self.api_client.call_api( *_param, _request_timeout=_request_timeout ) await response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ).data @validate_call async def alert_email_group_create_with_http_info( self, tenant: Annotated[ str, Field( min_length=36, strict=True, max_length=36, description="The tenant id" ), ], create_tenant_alert_email_group_request: Annotated[ CreateTenantAlertEmailGroupRequest, Field(description="The tenant alert email group to create"), ], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ], ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[TenantAlertEmailGroup]: """Create tenant alert email group Creates a new tenant alert email group :param tenant: The tenant id (required) :type tenant: str :param create_tenant_alert_email_group_request: The tenant alert email group to create (required) :type create_tenant_alert_email_group_request: CreateTenantAlertEmailGroupRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._alert_email_group_create_serialize( tenant=tenant, create_tenant_alert_email_group_request=create_tenant_alert_email_group_request, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index, ) _response_types_map: Dict[str, Optional[str]] = { "201": "TenantAlertEmailGroup", "400": "APIErrors", "403": "APIError", } response_data = await self.api_client.call_api( *_param, _request_timeout=_request_timeout ) await response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ) @validate_call async def alert_email_group_create_without_preload_content( self, tenant: Annotated[ str, Field( min_length=36, strict=True, max_length=36, description="The tenant id" ), ], create_tenant_alert_email_group_request: Annotated[ CreateTenantAlertEmailGroupRequest, Field(description="The tenant alert email group to create"), ], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ], ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: """Create tenant alert email group Creates a new tenant alert email group :param tenant: The tenant id (required) :type tenant: str :param create_tenant_alert_email_group_request: The tenant alert email group to create (required) :type create_tenant_alert_email_group_request: CreateTenantAlertEmailGroupRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._alert_email_group_create_serialize( tenant=tenant, create_tenant_alert_email_group_request=create_tenant_alert_email_group_request, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index, ) _response_types_map: Dict[str, Optional[str]] = { "201": "TenantAlertEmailGroup", "400": "APIErrors", "403": "APIError", } response_data = await self.api_client.call_api( *_param, _request_timeout=_request_timeout ) return response_data.response def _alert_email_group_create_serialize( self, tenant, create_tenant_alert_email_group_request, _request_auth, _content_type, _headers, _host_index, ) -> RequestSerialized: _host = None _collection_formats: Dict[str, str] = {} _path_params: Dict[str, str] = {} _query_params: List[Tuple[str, str]] = [] _header_params: Dict[str, Optional[str]] = _headers or {} _form_params: List[Tuple[str, str]] = [] _files: Dict[ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]] ] = {} _body_params: Optional[bytes] = None # process the path parameters if tenant is not None: _path_params["tenant"] = tenant # process the query parameters # process the header parameters # process the form parameters # process the body parameter if create_tenant_alert_email_group_request is not None: _body_params = create_tenant_alert_email_group_request # set the HTTP header `Accept` if "Accept" not in _header_params: _header_params["Accept"] = self.api_client.select_header_accept( ["application/json"] ) # set the HTTP header `Content-Type` if _content_type: _header_params["Content-Type"] = _content_type else: _default_content_type = self.api_client.select_header_content_type( ["application/json"] ) if _default_content_type is not None: _header_params["Content-Type"] = _default_content_type # authentication setting _auth_settings: List[str] = ["cookieAuth", "bearerAuth"] return self.api_client.param_serialize( method="POST", resource_path="/api/v1/tenants/{tenant}/alerting-email-groups", path_params=_path_params, query_params=_query_params, header_params=_header_params, body=_body_params, post_params=_form_params, files=_files, auth_settings=_auth_settings, collection_formats=_collection_formats, _host=_host, _request_auth=_request_auth, ) @validate_call async def alert_email_group_delete( self, alert_email_group: Annotated[ str, Field( min_length=36, strict=True, max_length=36, description="The tenant alert email group id", ), ], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ], ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> None: """Delete tenant alert email group Deletes a tenant alert email group :param alert_email_group: The tenant alert email group id (required) :type alert_email_group: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._alert_email_group_delete_serialize( alert_email_group=alert_email_group, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index, ) _response_types_map: Dict[str, Optional[str]] = { "204": None, "400": "APIErrors", "403": "APIError", } response_data = await self.api_client.call_api( *_param, _request_timeout=_request_timeout ) await response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ).data @validate_call async def alert_email_group_delete_with_http_info( self, alert_email_group: Annotated[ str, Field( min_length=36, strict=True, max_length=36, description="The tenant alert email group id", ), ], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ], ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[None]: """Delete tenant alert email group Deletes a tenant alert email group :param alert_email_group: The tenant alert email group id (required) :type alert_email_group: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._alert_email_group_delete_serialize( alert_email_group=alert_email_group, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index, ) _response_types_map: Dict[str, Optional[str]] = { "204": None, "400": "APIErrors", "403": "APIError", } response_data = await self.api_client.call_api( *_param, _request_timeout=_request_timeout ) await response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ) @validate_call async def alert_email_group_delete_without_preload_content( self, alert_email_group: Annotated[ str, Field( min_length=36, strict=True, max_length=36, description="The tenant alert email group id", ), ], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ], ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: """Delete tenant alert email group Deletes a tenant alert email group :param alert_email_group: The tenant alert email group id (required) :type alert_email_group: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._alert_email_group_delete_serialize( alert_email_group=alert_email_group, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index, ) _response_types_map: Dict[str, Optional[str]] = { "204": None, "400": "APIErrors", "403": "APIError", } response_data = await self.api_client.call_api( *_param, _request_timeout=_request_timeout ) return response_data.response def _alert_email_group_delete_serialize( self, alert_email_group, _request_auth, _content_type, _headers, _host_index, ) -> RequestSerialized: _host = None _collection_formats: Dict[str, str] = {} _path_params: Dict[str, str] = {} _query_params: List[Tuple[str, str]] = [] _header_params: Dict[str, Optional[str]] = _headers or {} _form_params: List[Tuple[str, str]] = [] _files: Dict[ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]] ] = {} _body_params: Optional[bytes] = None # process the path parameters if alert_email_group is not None: _path_params["alert-email-group"] = alert_email_group # process the query parameters # process the header parameters # process the form parameters # process the body parameter # set the HTTP header `Accept` if "Accept" not in _header_params: _header_params["Accept"] = self.api_client.select_header_accept( ["application/json"] ) # authentication setting _auth_settings: List[str] = ["cookieAuth", "bearerAuth"] return self.api_client.param_serialize( method="DELETE", resource_path="/api/v1/alerting-email-groups/{alert-email-group}", path_params=_path_params, query_params=_query_params, header_params=_header_params, body=_body_params, post_params=_form_params, files=_files, auth_settings=_auth_settings, collection_formats=_collection_formats, _host=_host, _request_auth=_request_auth, ) @validate_call async def alert_email_group_list( self, tenant: Annotated[ str, Field( min_length=36, strict=True, max_length=36, description="The tenant id" ), ], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ], ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> TenantAlertEmailGroupList: """List tenant alert email groups Gets a list of tenant alert email groups :param tenant: The tenant id (required) :type tenant: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._alert_email_group_list_serialize( tenant=tenant, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index, ) _response_types_map: Dict[str, Optional[str]] = { "200": "TenantAlertEmailGroupList", "400": "APIErrors", "403": "APIError", } response_data = await self.api_client.call_api( *_param, _request_timeout=_request_timeout ) await response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ).data @validate_call async def alert_email_group_list_with_http_info( self, tenant: Annotated[ str, Field( min_length=36, strict=True, max_length=36, description="The tenant id" ), ], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ], ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[TenantAlertEmailGroupList]: """List tenant alert email groups Gets a list of tenant alert email groups :param tenant: The tenant id (required) :type tenant: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._alert_email_group_list_serialize( tenant=tenant, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index, ) _response_types_map: Dict[str, Optional[str]] = { "200": "TenantAlertEmailGroupList", "400": "APIErrors", "403": "APIError", } response_data = await self.api_client.call_api( *_param, _request_timeout=_request_timeout ) await response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ) @validate_call async def alert_email_group_list_without_preload_content( self, tenant: Annotated[ str, Field( min_length=36, strict=True, max_length=36, description="The tenant id" ), ], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ], ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: """List tenant alert email groups Gets a list of tenant alert email groups :param tenant: The tenant id (required) :type tenant: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._alert_email_group_list_serialize( tenant=tenant, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index, ) _response_types_map: Dict[str, Optional[str]] = { "200": "TenantAlertEmailGroupList", "400": "APIErrors", "403": "APIError", } response_data = await self.api_client.call_api( *_param, _request_timeout=_request_timeout ) return response_data.response def _alert_email_group_list_serialize( self, tenant, _request_auth, _content_type, _headers, _host_index, ) -> RequestSerialized: _host = None _collection_formats: Dict[str, str] = {} _path_params: Dict[str, str] = {} _query_params: List[Tuple[str, str]] = [] _header_params: Dict[str, Optional[str]] = _headers or {} _form_params: List[Tuple[str, str]] = [] _files: Dict[ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]] ] = {} _body_params: Optional[bytes] = None # process the path parameters if tenant is not None: _path_params["tenant"] = tenant # process the query parameters # process the header parameters # process the form parameters # process the body parameter # set the HTTP header `Accept` if "Accept" not in _header_params: _header_params["Accept"] = self.api_client.select_header_accept( ["application/json"] ) # authentication setting _auth_settings: List[str] = ["cookieAuth", "bearerAuth"] return self.api_client.param_serialize( method="GET", resource_path="/api/v1/tenants/{tenant}/alerting-email-groups", path_params=_path_params, query_params=_query_params, header_params=_header_params, body=_body_params, post_params=_form_params, files=_files, auth_settings=_auth_settings, collection_formats=_collection_formats, _host=_host, _request_auth=_request_auth, ) @validate_call async def alert_email_group_update( self, alert_email_group: Annotated[ str, Field( min_length=36, strict=True, max_length=36, description="The tenant alert email group id", ), ], update_tenant_alert_email_group_request: Annotated[ UpdateTenantAlertEmailGroupRequest, Field(description="The tenant alert email group to update"), ], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ], ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> TenantAlertEmailGroup: """Update tenant alert email group Updates a tenant alert email group :param alert_email_group: The tenant alert email group id (required) :type alert_email_group: str :param update_tenant_alert_email_group_request: The tenant alert email group to update (required) :type update_tenant_alert_email_group_request: UpdateTenantAlertEmailGroupRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._alert_email_group_update_serialize( alert_email_group=alert_email_group, update_tenant_alert_email_group_request=update_tenant_alert_email_group_request, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index, ) _response_types_map: Dict[str, Optional[str]] = { "200": "TenantAlertEmailGroup", "400": "APIErrors", "403": "APIError", } response_data = await self.api_client.call_api( *_param, _request_timeout=_request_timeout ) await response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ).data @validate_call async def alert_email_group_update_with_http_info( self, alert_email_group: Annotated[ str, Field( min_length=36, strict=True, max_length=36, description="The tenant alert email group id", ), ], update_tenant_alert_email_group_request: Annotated[ UpdateTenantAlertEmailGroupRequest, Field(description="The tenant alert email group to update"), ], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ], ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[TenantAlertEmailGroup]: """Update tenant alert email group Updates a tenant alert email group :param alert_email_group: The tenant alert email group id (required) :type alert_email_group: str :param update_tenant_alert_email_group_request: The tenant alert email group to update (required) :type update_tenant_alert_email_group_request: UpdateTenantAlertEmailGroupRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._alert_email_group_update_serialize( alert_email_group=alert_email_group, update_tenant_alert_email_group_request=update_tenant_alert_email_group_request, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index, ) _response_types_map: Dict[str, Optional[str]] = { "200": "TenantAlertEmailGroup", "400": "APIErrors", "403": "APIError", } response_data = await self.api_client.call_api( *_param, _request_timeout=_request_timeout ) await response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ) @validate_call async def alert_email_group_update_without_preload_content( self, alert_email_group: Annotated[ str, Field( min_length=36, strict=True, max_length=36, description="The tenant alert email group id", ), ], update_tenant_alert_email_group_request: Annotated[ UpdateTenantAlertEmailGroupRequest, Field(description="The tenant alert email group to update"), ], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ], ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: """Update tenant alert email group Updates a tenant alert email group :param alert_email_group: The tenant alert email group id (required) :type alert_email_group: str :param update_tenant_alert_email_group_request: The tenant alert email group to update (required) :type update_tenant_alert_email_group_request: UpdateTenantAlertEmailGroupRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._alert_email_group_update_serialize( alert_email_group=alert_email_group, update_tenant_alert_email_group_request=update_tenant_alert_email_group_request, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index, ) _response_types_map: Dict[str, Optional[str]] = { "200": "TenantAlertEmailGroup", "400": "APIErrors", "403": "APIError", } response_data = await self.api_client.call_api( *_param, _request_timeout=_request_timeout ) return response_data.response def _alert_email_group_update_serialize( self, alert_email_group, update_tenant_alert_email_group_request, _request_auth, _content_type, _headers, _host_index, ) -> RequestSerialized: _host = None _collection_formats: Dict[str, str] = {} _path_params: Dict[str, str] = {} _query_params: List[Tuple[str, str]] = [] _header_params: Dict[str, Optional[str]] = _headers or {} _form_params: List[Tuple[str, str]] = [] _files: Dict[ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]] ] = {} _body_params: Optional[bytes] = None # process the path parameters if alert_email_group is not None: _path_params["alert-email-group"] = alert_email_group # process the query parameters # process the header parameters # process the form parameters # process the body parameter if update_tenant_alert_email_group_request is not None: _body_params = update_tenant_alert_email_group_request # set the HTTP header `Accept` if "Accept" not in _header_params: _header_params["Accept"] = self.api_client.select_header_accept( ["application/json"] ) # set the HTTP header `Content-Type` if _content_type: _header_params["Content-Type"] = _content_type else: _default_content_type = self.api_client.select_header_content_type( ["application/json"] ) if _default_content_type is not None: _header_params["Content-Type"] = _default_content_type # authentication setting _auth_settings: List[str] = ["cookieAuth", "bearerAuth"] return self.api_client.param_serialize( method="PATCH", resource_path="/api/v1/alerting-email-groups/{alert-email-group}", path_params=_path_params, query_params=_query_params, header_params=_header_params, body=_body_params, post_params=_form_params, files=_files, auth_settings=_auth_settings, collection_formats=_collection_formats, _host=_host, _request_auth=_request_auth, ) @validate_call async def tenant_alerting_settings_get( self, tenant: Annotated[ str, Field( min_length=36, strict=True, max_length=36, description="The tenant id" ), ], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ], ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> TenantAlertingSettings: """Get tenant alerting settings Gets the alerting settings for a tenant :param tenant: The tenant id (required) :type tenant: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._tenant_alerting_settings_get_serialize( tenant=tenant, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index, ) _response_types_map: Dict[str, Optional[str]] = { "200": "TenantAlertingSettings", "400": "APIErrors", "403": "APIError", } response_data = await self.api_client.call_api( *_param, _request_timeout=_request_timeout ) await response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ).data @validate_call async def tenant_alerting_settings_get_with_http_info( self, tenant: Annotated[ str, Field( min_length=36, strict=True, max_length=36, description="The tenant id" ), ], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ], ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[TenantAlertingSettings]: """Get tenant alerting settings Gets the alerting settings for a tenant :param tenant: The tenant id (required) :type tenant: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._tenant_alerting_settings_get_serialize( tenant=tenant, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index, ) _response_types_map: Dict[str, Optional[str]] = { "200": "TenantAlertingSettings", "400": "APIErrors", "403": "APIError", } response_data = await self.api_client.call_api( *_param, _request_timeout=_request_timeout ) await response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ) @validate_call async def tenant_alerting_settings_get_without_preload_content( self, tenant: Annotated[ str, Field( min_length=36, strict=True, max_length=36, description="The tenant id" ), ], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ], ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: """Get tenant alerting settings Gets the alerting settings for a tenant :param tenant: The tenant id (required) :type tenant: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._tenant_alerting_settings_get_serialize( tenant=tenant, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index, ) _response_types_map: Dict[str, Optional[str]] = { "200": "TenantAlertingSettings", "400": "APIErrors", "403": "APIError", } response_data = await self.api_client.call_api( *_param, _request_timeout=_request_timeout ) return response_data.response def _tenant_alerting_settings_get_serialize( self, tenant, _request_auth, _content_type, _headers, _host_index, ) -> RequestSerialized: _host = None _collection_formats: Dict[str, str] = {} _path_params: Dict[str, str] = {} _query_params: List[Tuple[str, str]] = [] _header_params: Dict[str, Optional[str]] = _headers or {} _form_params: List[Tuple[str, str]] = [] _files: Dict[ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]] ] = {} _body_params: Optional[bytes] = None # process the path parameters if tenant is not None: _path_params["tenant"] = tenant # process the query parameters # process the header parameters # process the form parameters # process the body parameter # set the HTTP header `Accept` if "Accept" not in _header_params: _header_params["Accept"] = self.api_client.select_header_accept( ["application/json"] ) # authentication setting _auth_settings: List[str] = ["cookieAuth", "bearerAuth"] return self.api_client.param_serialize( method="GET", resource_path="/api/v1/tenants/{tenant}/alerting/settings", path_params=_path_params, query_params=_query_params, header_params=_header_params, body=_body_params, post_params=_form_params, files=_files, auth_settings=_auth_settings, collection_formats=_collection_formats, _host=_host, _request_auth=_request_auth, ) @validate_call async def tenant_create( self, create_tenant_request: Annotated[ CreateTenantRequest, Field(description="The tenant to create") ], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ], ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> Tenant: """Create tenant Creates a new tenant :param create_tenant_request: The tenant to create (required) :type create_tenant_request: CreateTenantRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._tenant_create_serialize( create_tenant_request=create_tenant_request, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index, ) _response_types_map: Dict[str, Optional[str]] = { "200": "Tenant", "400": "APIErrors", "403": "APIError", } response_data = await self.api_client.call_api( *_param, _request_timeout=_request_timeout ) await response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ).data @validate_call async def tenant_create_with_http_info( self, create_tenant_request: Annotated[ CreateTenantRequest, Field(description="The tenant to create") ], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ], ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[Tenant]: """Create tenant Creates a new tenant :param create_tenant_request: The tenant to create (required) :type create_tenant_request: CreateTenantRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._tenant_create_serialize( create_tenant_request=create_tenant_request, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index, ) _response_types_map: Dict[str, Optional[str]] = { "200": "Tenant", "400": "APIErrors", "403": "APIError", } response_data = await self.api_client.call_api( *_param, _request_timeout=_request_timeout ) await response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ) @validate_call async def tenant_create_without_preload_content( self, create_tenant_request: Annotated[ CreateTenantRequest, Field(description="The tenant to create") ], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ], ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: """Create tenant Creates a new tenant :param create_tenant_request: The tenant to create (required) :type create_tenant_request: CreateTenantRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._tenant_create_serialize( create_tenant_request=create_tenant_request, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index, ) _response_types_map: Dict[str, Optional[str]] = { "200": "Tenant", "400": "APIErrors", "403": "APIError", } response_data = await self.api_client.call_api( *_param, _request_timeout=_request_timeout ) return response_data.response def _tenant_create_serialize( self, create_tenant_request, _request_auth, _content_type, _headers, _host_index, ) -> RequestSerialized: _host = None _collection_formats: Dict[str, str] = {} _path_params: Dict[str, str] = {} _query_params: List[Tuple[str, str]] = [] _header_params: Dict[str, Optional[str]] = _headers or {} _form_params: List[Tuple[str, str]] = [] _files: Dict[ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]] ] = {} _body_params: Optional[bytes] = None # process the path parameters # process the query parameters # process the header parameters # process the form parameters # process the body parameter if create_tenant_request is not None: _body_params = create_tenant_request # set the HTTP header `Accept` if "Accept" not in _header_params: _header_params["Accept"] = self.api_client.select_header_accept( ["application/json"] ) # set the HTTP header `Content-Type` if _content_type: _header_params["Content-Type"] = _content_type else: _default_content_type = self.api_client.select_header_content_type( ["application/json"] ) if _default_content_type is not None: _header_params["Content-Type"] = _default_content_type # authentication setting _auth_settings: List[str] = ["cookieAuth", "bearerAuth"] return self.api_client.param_serialize( method="POST", resource_path="/api/v1/tenants", path_params=_path_params, query_params=_query_params, header_params=_header_params, body=_body_params, post_params=_form_params, files=_files, auth_settings=_auth_settings, collection_formats=_collection_formats, _host=_host, _request_auth=_request_auth, ) @validate_call async def tenant_get_step_run_queue_metrics( self, tenant: Annotated[ str, Field( min_length=36, strict=True, max_length=36, description="The tenant id" ), ], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ], ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> TenantStepRunQueueMetrics: """Get step run metrics Get the queue metrics for the tenant :param tenant: The tenant id (required) :type tenant: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._tenant_get_step_run_queue_metrics_serialize( tenant=tenant, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index, ) _response_types_map: Dict[str, Optional[str]] = { "200": "TenantStepRunQueueMetrics", "400": "APIErrors", "403": "APIErrors", "404": "APIErrors", } response_data = await self.api_client.call_api( *_param, _request_timeout=_request_timeout ) await response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ).data @validate_call async def tenant_get_step_run_queue_metrics_with_http_info( self, tenant: Annotated[ str, Field( min_length=36, strict=True, max_length=36, description="The tenant id" ), ], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ], ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[TenantStepRunQueueMetrics]: """Get step run metrics Get the queue metrics for the tenant :param tenant: The tenant id (required) :type tenant: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._tenant_get_step_run_queue_metrics_serialize( tenant=tenant, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index, ) _response_types_map: Dict[str, Optional[str]] = { "200": "TenantStepRunQueueMetrics", "400": "APIErrors", "403": "APIErrors", "404": "APIErrors", } response_data = await self.api_client.call_api( *_param, _request_timeout=_request_timeout ) await response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ) @validate_call async def tenant_get_step_run_queue_metrics_without_preload_content( self, tenant: Annotated[ str, Field( min_length=36, strict=True, max_length=36, description="The tenant id" ), ], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ], ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: """Get step run metrics Get the queue metrics for the tenant :param tenant: The tenant id (required) :type tenant: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._tenant_get_step_run_queue_metrics_serialize( tenant=tenant, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index, ) _response_types_map: Dict[str, Optional[str]] = { "200": "TenantStepRunQueueMetrics", "400": "APIErrors", "403": "APIErrors", "404": "APIErrors", } response_data = await self.api_client.call_api( *_param, _request_timeout=_request_timeout ) return response_data.response def _tenant_get_step_run_queue_metrics_serialize( self, tenant, _request_auth, _content_type, _headers, _host_index, ) -> RequestSerialized: _host = None _collection_formats: Dict[str, str] = {} _path_params: Dict[str, str] = {} _query_params: List[Tuple[str, str]] = [] _header_params: Dict[str, Optional[str]] = _headers or {} _form_params: List[Tuple[str, str]] = [] _files: Dict[ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]] ] = {} _body_params: Optional[bytes] = None # process the path parameters if tenant is not None: _path_params["tenant"] = tenant # process the query parameters # process the header parameters # process the form parameters # process the body parameter # set the HTTP header `Accept` if "Accept" not in _header_params: _header_params["Accept"] = self.api_client.select_header_accept( ["application/json"] ) # authentication setting _auth_settings: List[str] = ["cookieAuth", "bearerAuth"] return self.api_client.param_serialize( method="GET", resource_path="/api/v1/tenants/{tenant}/step-run-queue-metrics", path_params=_path_params, query_params=_query_params, header_params=_header_params, body=_body_params, post_params=_form_params, files=_files, auth_settings=_auth_settings, collection_formats=_collection_formats, _host=_host, _request_auth=_request_auth, ) @validate_call async def tenant_invite_accept( self, accept_invite_request: Optional[AcceptInviteRequest] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ], ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> None: """Accept tenant invite Accepts a tenant invite :param accept_invite_request: :type accept_invite_request: AcceptInviteRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._tenant_invite_accept_serialize( accept_invite_request=accept_invite_request, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index, ) _response_types_map: Dict[str, Optional[str]] = { "200": None, "400": "APIErrors", "403": "APIError", } response_data = await self.api_client.call_api( *_param, _request_timeout=_request_timeout ) await response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ).data @validate_call async def tenant_invite_accept_with_http_info( self, accept_invite_request: Optional[AcceptInviteRequest] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ], ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[None]: """Accept tenant invite Accepts a tenant invite :param accept_invite_request: :type accept_invite_request: AcceptInviteRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._tenant_invite_accept_serialize( accept_invite_request=accept_invite_request, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index, ) _response_types_map: Dict[str, Optional[str]] = { "200": None, "400": "APIErrors", "403": "APIError", } response_data = await self.api_client.call_api( *_param, _request_timeout=_request_timeout ) await response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ) @validate_call async def tenant_invite_accept_without_preload_content( self, accept_invite_request: Optional[AcceptInviteRequest] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ], ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: """Accept tenant invite Accepts a tenant invite :param accept_invite_request: :type accept_invite_request: AcceptInviteRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._tenant_invite_accept_serialize( accept_invite_request=accept_invite_request, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index, ) _response_types_map: Dict[str, Optional[str]] = { "200": None, "400": "APIErrors", "403": "APIError", } response_data = await self.api_client.call_api( *_param, _request_timeout=_request_timeout ) return response_data.response def _tenant_invite_accept_serialize( self, accept_invite_request, _request_auth, _content_type, _headers, _host_index, ) -> RequestSerialized: _host = None _collection_formats: Dict[str, str] = {} _path_params: Dict[str, str] = {} _query_params: List[Tuple[str, str]] = [] _header_params: Dict[str, Optional[str]] = _headers or {} _form_params: List[Tuple[str, str]] = [] _files: Dict[ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]] ] = {} _body_params: Optional[bytes] = None # process the path parameters # process the query parameters # process the header parameters # process the form parameters # process the body parameter if accept_invite_request is not None: _body_params = accept_invite_request # set the HTTP header `Accept` if "Accept" not in _header_params: _header_params["Accept"] = self.api_client.select_header_accept( ["application/json"] ) # set the HTTP header `Content-Type` if _content_type: _header_params["Content-Type"] = _content_type else: _default_content_type = self.api_client.select_header_content_type( ["application/json"] ) if _default_content_type is not None: _header_params["Content-Type"] = _default_content_type # authentication setting _auth_settings: List[str] = ["cookieAuth", "bearerAuth"] return self.api_client.param_serialize( method="POST", resource_path="/api/v1/users/invites/accept", path_params=_path_params, query_params=_query_params, header_params=_header_params, body=_body_params, post_params=_form_params, files=_files, auth_settings=_auth_settings, collection_formats=_collection_formats, _host=_host, _request_auth=_request_auth, ) @validate_call async def tenant_invite_create( self, tenant: Annotated[ str, Field( min_length=36, strict=True, max_length=36, description="The tenant id" ), ], create_tenant_invite_request: Annotated[ CreateTenantInviteRequest, Field(description="The tenant invite to create") ], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ], ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> TenantInvite: """Create tenant invite Creates a new tenant invite :param tenant: The tenant id (required) :type tenant: str :param create_tenant_invite_request: The tenant invite to create (required) :type create_tenant_invite_request: CreateTenantInviteRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._tenant_invite_create_serialize( tenant=tenant, create_tenant_invite_request=create_tenant_invite_request, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index, ) _response_types_map: Dict[str, Optional[str]] = { "201": "TenantInvite", "400": "APIErrors", "403": "APIError", } response_data = await self.api_client.call_api( *_param, _request_timeout=_request_timeout ) await response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ).data @validate_call async def tenant_invite_create_with_http_info( self, tenant: Annotated[ str, Field( min_length=36, strict=True, max_length=36, description="The tenant id" ), ], create_tenant_invite_request: Annotated[ CreateTenantInviteRequest, Field(description="The tenant invite to create") ], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ], ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[TenantInvite]: """Create tenant invite Creates a new tenant invite :param tenant: The tenant id (required) :type tenant: str :param create_tenant_invite_request: The tenant invite to create (required) :type create_tenant_invite_request: CreateTenantInviteRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._tenant_invite_create_serialize( tenant=tenant, create_tenant_invite_request=create_tenant_invite_request, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index, ) _response_types_map: Dict[str, Optional[str]] = { "201": "TenantInvite", "400": "APIErrors", "403": "APIError", } response_data = await self.api_client.call_api( *_param, _request_timeout=_request_timeout ) await response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ) @validate_call async def tenant_invite_create_without_preload_content( self, tenant: Annotated[ str, Field( min_length=36, strict=True, max_length=36, description="The tenant id" ), ], create_tenant_invite_request: Annotated[ CreateTenantInviteRequest, Field(description="The tenant invite to create") ], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ], ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: """Create tenant invite Creates a new tenant invite :param tenant: The tenant id (required) :type tenant: str :param create_tenant_invite_request: The tenant invite to create (required) :type create_tenant_invite_request: CreateTenantInviteRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._tenant_invite_create_serialize( tenant=tenant, create_tenant_invite_request=create_tenant_invite_request, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index, ) _response_types_map: Dict[str, Optional[str]] = { "201": "TenantInvite", "400": "APIErrors", "403": "APIError", } response_data = await self.api_client.call_api( *_param, _request_timeout=_request_timeout ) return response_data.response def _tenant_invite_create_serialize( self, tenant, create_tenant_invite_request, _request_auth, _content_type, _headers, _host_index, ) -> RequestSerialized: _host = None _collection_formats: Dict[str, str] = {} _path_params: Dict[str, str] = {} _query_params: List[Tuple[str, str]] = [] _header_params: Dict[str, Optional[str]] = _headers or {} _form_params: List[Tuple[str, str]] = [] _files: Dict[ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]] ] = {} _body_params: Optional[bytes] = None # process the path parameters if tenant is not None: _path_params["tenant"] = tenant # process the query parameters # process the header parameters # process the form parameters # process the body parameter if create_tenant_invite_request is not None: _body_params = create_tenant_invite_request # set the HTTP header `Accept` if "Accept" not in _header_params: _header_params["Accept"] = self.api_client.select_header_accept( ["application/json"] ) # set the HTTP header `Content-Type` if _content_type: _header_params["Content-Type"] = _content_type else: _default_content_type = self.api_client.select_header_content_type( ["application/json"] ) if _default_content_type is not None: _header_params["Content-Type"] = _default_content_type # authentication setting _auth_settings: List[str] = ["cookieAuth", "bearerAuth"] return self.api_client.param_serialize( method="POST", resource_path="/api/v1/tenants/{tenant}/invites", path_params=_path_params, query_params=_query_params, header_params=_header_params, body=_body_params, post_params=_form_params, files=_files, auth_settings=_auth_settings, collection_formats=_collection_formats, _host=_host, _request_auth=_request_auth, ) @validate_call async def tenant_invite_list( self, tenant: Annotated[ str, Field( min_length=36, strict=True, max_length=36, description="The tenant id" ), ], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ], ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> TenantInviteList: """List tenant invites Gets a list of tenant invites :param tenant: The tenant id (required) :type tenant: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._tenant_invite_list_serialize( tenant=tenant, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index, ) _response_types_map: Dict[str, Optional[str]] = { "200": "TenantInviteList", "400": "APIErrors", "403": "APIError", } response_data = await self.api_client.call_api( *_param, _request_timeout=_request_timeout ) await response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ).data @validate_call async def tenant_invite_list_with_http_info( self, tenant: Annotated[ str, Field( min_length=36, strict=True, max_length=36, description="The tenant id" ), ], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ], ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[TenantInviteList]: """List tenant invites Gets a list of tenant invites :param tenant: The tenant id (required) :type tenant: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._tenant_invite_list_serialize( tenant=tenant, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index, ) _response_types_map: Dict[str, Optional[str]] = { "200": "TenantInviteList", "400": "APIErrors", "403": "APIError", } response_data = await self.api_client.call_api( *_param, _request_timeout=_request_timeout ) await response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ) @validate_call async def tenant_invite_list_without_preload_content( self, tenant: Annotated[ str, Field( min_length=36, strict=True, max_length=36, description="The tenant id" ), ], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ], ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: """List tenant invites Gets a list of tenant invites :param tenant: The tenant id (required) :type tenant: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._tenant_invite_list_serialize( tenant=tenant, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index, ) _response_types_map: Dict[str, Optional[str]] = { "200": "TenantInviteList", "400": "APIErrors", "403": "APIError", } response_data = await self.api_client.call_api( *_param, _request_timeout=_request_timeout ) return response_data.response def _tenant_invite_list_serialize( self, tenant, _request_auth, _content_type, _headers, _host_index, ) -> RequestSerialized: _host = None _collection_formats: Dict[str, str] = {} _path_params: Dict[str, str] = {} _query_params: List[Tuple[str, str]] = [] _header_params: Dict[str, Optional[str]] = _headers or {} _form_params: List[Tuple[str, str]] = [] _files: Dict[ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]] ] = {} _body_params: Optional[bytes] = None # process the path parameters if tenant is not None: _path_params["tenant"] = tenant # process the query parameters # process the header parameters # process the form parameters # process the body parameter # set the HTTP header `Accept` if "Accept" not in _header_params: _header_params["Accept"] = self.api_client.select_header_accept( ["application/json"] ) # authentication setting _auth_settings: List[str] = ["cookieAuth", "bearerAuth"] return self.api_client.param_serialize( method="GET", resource_path="/api/v1/tenants/{tenant}/invites", path_params=_path_params, query_params=_query_params, header_params=_header_params, body=_body_params, post_params=_form_params, files=_files, auth_settings=_auth_settings, collection_formats=_collection_formats, _host=_host, _request_auth=_request_auth, ) @validate_call async def tenant_invite_reject( self, reject_invite_request: Optional[RejectInviteRequest] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ], ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> None: """Reject tenant invite Rejects a tenant invite :param reject_invite_request: :type reject_invite_request: RejectInviteRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._tenant_invite_reject_serialize( reject_invite_request=reject_invite_request, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index, ) _response_types_map: Dict[str, Optional[str]] = { "200": None, "400": "APIErrors", "403": "APIError", } response_data = await self.api_client.call_api( *_param, _request_timeout=_request_timeout ) await response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ).data @validate_call async def tenant_invite_reject_with_http_info( self, reject_invite_request: Optional[RejectInviteRequest] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ], ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[None]: """Reject tenant invite Rejects a tenant invite :param reject_invite_request: :type reject_invite_request: RejectInviteRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._tenant_invite_reject_serialize( reject_invite_request=reject_invite_request, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index, ) _response_types_map: Dict[str, Optional[str]] = { "200": None, "400": "APIErrors", "403": "APIError", } response_data = await self.api_client.call_api( *_param, _request_timeout=_request_timeout ) await response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ) @validate_call async def tenant_invite_reject_without_preload_content( self, reject_invite_request: Optional[RejectInviteRequest] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ], ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: """Reject tenant invite Rejects a tenant invite :param reject_invite_request: :type reject_invite_request: RejectInviteRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._tenant_invite_reject_serialize( reject_invite_request=reject_invite_request, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index, ) _response_types_map: Dict[str, Optional[str]] = { "200": None, "400": "APIErrors", "403": "APIError", } response_data = await self.api_client.call_api( *_param, _request_timeout=_request_timeout ) return response_data.response def _tenant_invite_reject_serialize( self, reject_invite_request, _request_auth, _content_type, _headers, _host_index, ) -> RequestSerialized: _host = None _collection_formats: Dict[str, str] = {} _path_params: Dict[str, str] = {} _query_params: List[Tuple[str, str]] = [] _header_params: Dict[str, Optional[str]] = _headers or {} _form_params: List[Tuple[str, str]] = [] _files: Dict[ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]] ] = {} _body_params: Optional[bytes] = None # process the path parameters # process the query parameters # process the header parameters # process the form parameters # process the body parameter if reject_invite_request is not None: _body_params = reject_invite_request # set the HTTP header `Accept` if "Accept" not in _header_params: _header_params["Accept"] = self.api_client.select_header_accept( ["application/json"] ) # set the HTTP header `Content-Type` if _content_type: _header_params["Content-Type"] = _content_type else: _default_content_type = self.api_client.select_header_content_type( ["application/json"] ) if _default_content_type is not None: _header_params["Content-Type"] = _default_content_type # authentication setting _auth_settings: List[str] = ["cookieAuth", "bearerAuth"] return self.api_client.param_serialize( method="POST", resource_path="/api/v1/users/invites/reject", path_params=_path_params, query_params=_query_params, header_params=_header_params, body=_body_params, post_params=_form_params, files=_files, auth_settings=_auth_settings, collection_formats=_collection_formats, _host=_host, _request_auth=_request_auth, ) @validate_call async def tenant_member_delete( self, tenant: Annotated[ str, Field( min_length=36, strict=True, max_length=36, description="The tenant id" ), ], member: Annotated[ str, Field( min_length=36, strict=True, max_length=36, description="The tenant member id", ), ], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ], ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> TenantMember: """Delete a tenant member Delete a member from a tenant :param tenant: The tenant id (required) :type tenant: str :param member: The tenant member id (required) :type member: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._tenant_member_delete_serialize( tenant=tenant, member=member, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index, ) _response_types_map: Dict[str, Optional[str]] = { "204": "TenantMember", "400": "APIErrors", "403": "APIErrors", "404": "APIErrors", } response_data = await self.api_client.call_api( *_param, _request_timeout=_request_timeout ) await response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ).data @validate_call async def tenant_member_delete_with_http_info( self, tenant: Annotated[ str, Field( min_length=36, strict=True, max_length=36, description="The tenant id" ), ], member: Annotated[ str, Field( min_length=36, strict=True, max_length=36, description="The tenant member id", ), ], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ], ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[TenantMember]: """Delete a tenant member Delete a member from a tenant :param tenant: The tenant id (required) :type tenant: str :param member: The tenant member id (required) :type member: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._tenant_member_delete_serialize( tenant=tenant, member=member, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index, ) _response_types_map: Dict[str, Optional[str]] = { "204": "TenantMember", "400": "APIErrors", "403": "APIErrors", "404": "APIErrors", } response_data = await self.api_client.call_api( *_param, _request_timeout=_request_timeout ) await response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ) @validate_call async def tenant_member_delete_without_preload_content( self, tenant: Annotated[ str, Field( min_length=36, strict=True, max_length=36, description="The tenant id" ), ], member: Annotated[ str, Field( min_length=36, strict=True, max_length=36, description="The tenant member id", ), ], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ], ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: """Delete a tenant member Delete a member from a tenant :param tenant: The tenant id (required) :type tenant: str :param member: The tenant member id (required) :type member: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._tenant_member_delete_serialize( tenant=tenant, member=member, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index, ) _response_types_map: Dict[str, Optional[str]] = { "204": "TenantMember", "400": "APIErrors", "403": "APIErrors", "404": "APIErrors", } response_data = await self.api_client.call_api( *_param, _request_timeout=_request_timeout ) return response_data.response def _tenant_member_delete_serialize( self, tenant, member, _request_auth, _content_type, _headers, _host_index, ) -> RequestSerialized: _host = None _collection_formats: Dict[str, str] = {} _path_params: Dict[str, str] = {} _query_params: List[Tuple[str, str]] = [] _header_params: Dict[str, Optional[str]] = _headers or {} _form_params: List[Tuple[str, str]] = [] _files: Dict[ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]] ] = {} _body_params: Optional[bytes] = None # process the path parameters if tenant is not None: _path_params["tenant"] = tenant if member is not None: _path_params["member"] = member # process the query parameters # process the header parameters # process the form parameters # process the body parameter # set the HTTP header `Accept` if "Accept" not in _header_params: _header_params["Accept"] = self.api_client.select_header_accept( ["application/json"] ) # authentication setting _auth_settings: List[str] = ["cookieAuth", "bearerAuth"] return self.api_client.param_serialize( method="DELETE", resource_path="/api/v1/tenants/{tenant}/members/{member}", path_params=_path_params, query_params=_query_params, header_params=_header_params, body=_body_params, post_params=_form_params, files=_files, auth_settings=_auth_settings, collection_formats=_collection_formats, _host=_host, _request_auth=_request_auth, ) @validate_call async def tenant_member_list( self, tenant: Annotated[ str, Field( min_length=36, strict=True, max_length=36, description="The tenant id" ), ], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ], ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> TenantMemberList: """List tenant members Gets a list of tenant members :param tenant: The tenant id (required) :type tenant: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._tenant_member_list_serialize( tenant=tenant, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index, ) _response_types_map: Dict[str, Optional[str]] = { "200": "TenantMemberList", "400": "APIErrors", "403": "APIError", } response_data = await self.api_client.call_api( *_param, _request_timeout=_request_timeout ) await response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ).data @validate_call async def tenant_member_list_with_http_info( self, tenant: Annotated[ str, Field( min_length=36, strict=True, max_length=36, description="The tenant id" ), ], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ], ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[TenantMemberList]: """List tenant members Gets a list of tenant members :param tenant: The tenant id (required) :type tenant: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._tenant_member_list_serialize( tenant=tenant, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index, ) _response_types_map: Dict[str, Optional[str]] = { "200": "TenantMemberList", "400": "APIErrors", "403": "APIError", } response_data = await self.api_client.call_api( *_param, _request_timeout=_request_timeout ) await response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ) @validate_call async def tenant_member_list_without_preload_content( self, tenant: Annotated[ str, Field( min_length=36, strict=True, max_length=36, description="The tenant id" ), ], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ], ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: """List tenant members Gets a list of tenant members :param tenant: The tenant id (required) :type tenant: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._tenant_member_list_serialize( tenant=tenant, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index, ) _response_types_map: Dict[str, Optional[str]] = { "200": "TenantMemberList", "400": "APIErrors", "403": "APIError", } response_data = await self.api_client.call_api( *_param, _request_timeout=_request_timeout ) return response_data.response def _tenant_member_list_serialize( self, tenant, _request_auth, _content_type, _headers, _host_index, ) -> RequestSerialized: _host = None _collection_formats: Dict[str, str] = {} _path_params: Dict[str, str] = {} _query_params: List[Tuple[str, str]] = [] _header_params: Dict[str, Optional[str]] = _headers or {} _form_params: List[Tuple[str, str]] = [] _files: Dict[ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]] ] = {} _body_params: Optional[bytes] = None # process the path parameters if tenant is not None: _path_params["tenant"] = tenant # process the query parameters # process the header parameters # process the form parameters # process the body parameter # set the HTTP header `Accept` if "Accept" not in _header_params: _header_params["Accept"] = self.api_client.select_header_accept( ["application/json"] ) # authentication setting _auth_settings: List[str] = ["cookieAuth", "bearerAuth"] return self.api_client.param_serialize( method="GET", resource_path="/api/v1/tenants/{tenant}/members", path_params=_path_params, query_params=_query_params, header_params=_header_params, body=_body_params, post_params=_form_params, files=_files, auth_settings=_auth_settings, collection_formats=_collection_formats, _host=_host, _request_auth=_request_auth, ) @validate_call async def tenant_resource_policy_get( self, tenant: Annotated[ str, Field( min_length=36, strict=True, max_length=36, description="The tenant id" ), ], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ], ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> TenantResourcePolicy: """Create tenant alert email group Gets the resource policy for a tenant :param tenant: The tenant id (required) :type tenant: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._tenant_resource_policy_get_serialize( tenant=tenant, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index, ) _response_types_map: Dict[str, Optional[str]] = { "200": "TenantResourcePolicy", "400": "APIErrors", "403": "APIError", } response_data = await self.api_client.call_api( *_param, _request_timeout=_request_timeout ) await response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ).data @validate_call async def tenant_resource_policy_get_with_http_info( self, tenant: Annotated[ str, Field( min_length=36, strict=True, max_length=36, description="The tenant id" ), ], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ], ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[TenantResourcePolicy]: """Create tenant alert email group Gets the resource policy for a tenant :param tenant: The tenant id (required) :type tenant: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._tenant_resource_policy_get_serialize( tenant=tenant, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index, ) _response_types_map: Dict[str, Optional[str]] = { "200": "TenantResourcePolicy", "400": "APIErrors", "403": "APIError", } response_data = await self.api_client.call_api( *_param, _request_timeout=_request_timeout ) await response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ) @validate_call async def tenant_resource_policy_get_without_preload_content( self, tenant: Annotated[ str, Field( min_length=36, strict=True, max_length=36, description="The tenant id" ), ], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ], ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: """Create tenant alert email group Gets the resource policy for a tenant :param tenant: The tenant id (required) :type tenant: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._tenant_resource_policy_get_serialize( tenant=tenant, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index, ) _response_types_map: Dict[str, Optional[str]] = { "200": "TenantResourcePolicy", "400": "APIErrors", "403": "APIError", } response_data = await self.api_client.call_api( *_param, _request_timeout=_request_timeout ) return response_data.response def _tenant_resource_policy_get_serialize( self, tenant, _request_auth, _content_type, _headers, _host_index, ) -> RequestSerialized: _host = None _collection_formats: Dict[str, str] = {} _path_params: Dict[str, str] = {} _query_params: List[Tuple[str, str]] = [] _header_params: Dict[str, Optional[str]] = _headers or {} _form_params: List[Tuple[str, str]] = [] _files: Dict[ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]] ] = {} _body_params: Optional[bytes] = None # process the path parameters if tenant is not None: _path_params["tenant"] = tenant # process the query parameters # process the header parameters # process the form parameters # process the body parameter # set the HTTP header `Accept` if "Accept" not in _header_params: _header_params["Accept"] = self.api_client.select_header_accept( ["application/json"] ) # authentication setting _auth_settings: List[str] = ["cookieAuth", "bearerAuth"] return self.api_client.param_serialize( method="GET", resource_path="/api/v1/tenants/{tenant}/resource-policy", path_params=_path_params, query_params=_query_params, header_params=_header_params, body=_body_params, post_params=_form_params, files=_files, auth_settings=_auth_settings, collection_formats=_collection_formats, _host=_host, _request_auth=_request_auth, ) @validate_call async def tenant_update( self, tenant: Annotated[ str, Field( min_length=36, strict=True, max_length=36, description="The tenant id" ), ], update_tenant_request: Annotated[ UpdateTenantRequest, Field(description="The tenant properties to update") ], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ], ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> Tenant: """Update tenant Update an existing tenant :param tenant: The tenant id (required) :type tenant: str :param update_tenant_request: The tenant properties to update (required) :type update_tenant_request: UpdateTenantRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._tenant_update_serialize( tenant=tenant, update_tenant_request=update_tenant_request, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index, ) _response_types_map: Dict[str, Optional[str]] = { "200": "Tenant", "400": "APIErrors", "403": "APIError", } response_data = await self.api_client.call_api( *_param, _request_timeout=_request_timeout ) await response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ).data @validate_call async def tenant_update_with_http_info( self, tenant: Annotated[ str, Field( min_length=36, strict=True, max_length=36, description="The tenant id" ), ], update_tenant_request: Annotated[ UpdateTenantRequest, Field(description="The tenant properties to update") ], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ], ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[Tenant]: """Update tenant Update an existing tenant :param tenant: The tenant id (required) :type tenant: str :param update_tenant_request: The tenant properties to update (required) :type update_tenant_request: UpdateTenantRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._tenant_update_serialize( tenant=tenant, update_tenant_request=update_tenant_request, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index, ) _response_types_map: Dict[str, Optional[str]] = { "200": "Tenant", "400": "APIErrors", "403": "APIError", } response_data = await self.api_client.call_api( *_param, _request_timeout=_request_timeout ) await response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ) @validate_call async def tenant_update_without_preload_content( self, tenant: Annotated[ str, Field( min_length=36, strict=True, max_length=36, description="The tenant id" ), ], update_tenant_request: Annotated[ UpdateTenantRequest, Field(description="The tenant properties to update") ], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ], ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: """Update tenant Update an existing tenant :param tenant: The tenant id (required) :type tenant: str :param update_tenant_request: The tenant properties to update (required) :type update_tenant_request: UpdateTenantRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._tenant_update_serialize( tenant=tenant, update_tenant_request=update_tenant_request, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index, ) _response_types_map: Dict[str, Optional[str]] = { "200": "Tenant", "400": "APIErrors", "403": "APIError", } response_data = await self.api_client.call_api( *_param, _request_timeout=_request_timeout ) return response_data.response def _tenant_update_serialize( self, tenant, update_tenant_request, _request_auth, _content_type, _headers, _host_index, ) -> RequestSerialized: _host = None _collection_formats: Dict[str, str] = {} _path_params: Dict[str, str] = {} _query_params: List[Tuple[str, str]] = [] _header_params: Dict[str, Optional[str]] = _headers or {} _form_params: List[Tuple[str, str]] = [] _files: Dict[ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]] ] = {} _body_params: Optional[bytes] = None # process the path parameters if tenant is not None: _path_params["tenant"] = tenant # process the query parameters # process the header parameters # process the form parameters # process the body parameter if update_tenant_request is not None: _body_params = update_tenant_request # set the HTTP header `Accept` if "Accept" not in _header_params: _header_params["Accept"] = self.api_client.select_header_accept( ["application/json"] ) # set the HTTP header `Content-Type` if _content_type: _header_params["Content-Type"] = _content_type else: _default_content_type = self.api_client.select_header_content_type( ["application/json"] ) if _default_content_type is not None: _header_params["Content-Type"] = _default_content_type # authentication setting _auth_settings: List[str] = ["cookieAuth", "bearerAuth"] return self.api_client.param_serialize( method="PATCH", resource_path="/api/v1/tenants/{tenant}", path_params=_path_params, query_params=_query_params, header_params=_header_params, body=_body_params, post_params=_form_params, files=_files, auth_settings=_auth_settings, collection_formats=_collection_formats, _host=_host, _request_auth=_request_auth, ) @validate_call async def user_list_tenant_invites( self, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ], ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> TenantInviteList: """List tenant invites Lists all tenant invites for the current user :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._user_list_tenant_invites_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index, ) _response_types_map: Dict[str, Optional[str]] = { "200": "TenantInviteList", "400": "APIErrors", "403": "APIErrors", } response_data = await self.api_client.call_api( *_param, _request_timeout=_request_timeout ) await response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ).data @validate_call async def user_list_tenant_invites_with_http_info( self, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ], ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[TenantInviteList]: """List tenant invites Lists all tenant invites for the current user :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._user_list_tenant_invites_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index, ) _response_types_map: Dict[str, Optional[str]] = { "200": "TenantInviteList", "400": "APIErrors", "403": "APIErrors", } response_data = await self.api_client.call_api( *_param, _request_timeout=_request_timeout ) await response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ) @validate_call async def user_list_tenant_invites_without_preload_content( self, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ], ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: """List tenant invites Lists all tenant invites for the current user :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._user_list_tenant_invites_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index, ) _response_types_map: Dict[str, Optional[str]] = { "200": "TenantInviteList", "400": "APIErrors", "403": "APIErrors", } response_data = await self.api_client.call_api( *_param, _request_timeout=_request_timeout ) return response_data.response def _user_list_tenant_invites_serialize( self, _request_auth, _content_type, _headers, _host_index, ) -> RequestSerialized: _host = None _collection_formats: Dict[str, str] = {} _path_params: Dict[str, str] = {} _query_params: List[Tuple[str, str]] = [] _header_params: Dict[str, Optional[str]] = _headers or {} _form_params: List[Tuple[str, str]] = [] _files: Dict[ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]] ] = {} _body_params: Optional[bytes] = None # process the path parameters # process the query parameters # process the header parameters # process the form parameters # process the body parameter # set the HTTP header `Accept` if "Accept" not in _header_params: _header_params["Accept"] = self.api_client.select_header_accept( ["application/json"] ) # authentication setting _auth_settings: List[str] = ["cookieAuth"] return self.api_client.param_serialize( method="GET", resource_path="/api/v1/users/invites", path_params=_path_params, query_params=_query_params, header_params=_header_params, body=_body_params, post_params=_form_params, files=_files, auth_settings=_auth_settings, collection_formats=_collection_formats, _host=_host, _request_auth=_request_auth, )