crypticorn 2.17.0rc7__py3-none-any.whl → 2.18.0__py3-none-any.whl

crypticorn/auth/client/api/auth_api.py

@@ -11,10 +11,14 @@ Generated by OpenAPI Generator (https://openapi-generator.tech)
 Do not edit the class manually.
 """  # noqa: E501
 
+import warnings
 from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
 from typing import Any, Dict, List, Optional, Tuple, Union
 from typing_extensions import Annotated
 
+from pydantic import Field, StrictStr, field_validator
+from typing import Any, List, Optional
+from typing_extensions import Annotated
 from crypticorn.auth.client.models.authorize_user200_response import (
     AuthorizeUser200Response,
 )
@@ -2229,13 +2233,8 @@ class AuthApi:
         )
 
     @validate_call
-    def oauth_callback(
+    def get_user_scopes(
         self,
-        code: StrictStr,
-        scope: StrictStr,
-        authuser: StrictStr,
-        prompt: StrictStr,
-        origin: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -2247,15 +2246,10 @@ class AuthApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> OauthCallback200Response:
-        """OAuth Callback"""
+    ) -> List[str]:
+        """Get User Scopes"""
         if self.is_sync:
-            return self._oauth_callback_sync(
-                code=code,
-                scope=scope,
-                authuser=authuser,
-                prompt=prompt,
-                origin=origin,
+            return self._get_user_scopes_sync(
                 _request_timeout=_request_timeout,
                 _request_auth=_request_auth,
                 _content_type=_content_type,
@@ -2264,12 +2258,7 @@ class AuthApi:
             )
 
         else:
-            return self._oauth_callback_async(
-                code=code,
-                scope=scope,
-                authuser=authuser,
-                prompt=prompt,
-                origin=origin,
+            return self._get_user_scopes_async(
                 _request_timeout=_request_timeout,
                 _request_auth=_request_auth,
                 _content_type=_content_type,
@@ -2278,13 +2267,8 @@ class AuthApi:
             )
 
     @validate_call
-    def oauth_callback_with_http_info(
+    def get_user_scopes_with_http_info(
         self,
-        code: StrictStr,
-        scope: StrictStr,
-        authuser: StrictStr,
-        prompt: StrictStr,
-        origin: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -2296,15 +2280,10 @@ class AuthApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[OauthCallback200Response]:
-        """OAuth Callback with HTTP info"""
+    ) -> ApiResponse[List[str]]:
+        """Get User Scopes with HTTP info"""
         if self.is_sync:
-            return self._oauth_callback_sync_with_http_info(
-                code=code,
-                scope=scope,
-                authuser=authuser,
-                prompt=prompt,
-                origin=origin,
+            return self._get_user_scopes_sync_with_http_info(
                 _request_timeout=_request_timeout,
                 _request_auth=_request_auth,
                 _content_type=_content_type,
@@ -2313,12 +2292,7 @@ class AuthApi:
             )
 
         else:
-            return self._oauth_callback_async_with_http_info(
-                code=code,
-                scope=scope,
-                authuser=authuser,
-                prompt=prompt,
-                origin=origin,
+            return self._get_user_scopes_async_with_http_info(
                 _request_timeout=_request_timeout,
                 _request_auth=_request_auth,
                 _content_type=_content_type,
@@ -2327,13 +2301,8 @@ class AuthApi:
             )
 
     @validate_call
-    def oauth_callback_without_preload_content(
+    def get_user_scopes_without_preload_content(
         self,
-        code: StrictStr,
-        scope: StrictStr,
-        authuser: StrictStr,
-        prompt: StrictStr,
-        origin: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -2346,14 +2315,9 @@ class AuthApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """OAuth Callback without preloading content"""
+        """Get User Scopes without preloading content"""
         if self.is_sync:
-            return self._oauth_callback_sync_without_preload_content(
-                code=code,
-                scope=scope,
-                authuser=authuser,
-                prompt=prompt,
-                origin=origin,
+            return self._get_user_scopes_sync_without_preload_content(
                 _request_timeout=_request_timeout,
                 _request_auth=_request_auth,
                 _content_type=_content_type,
@@ -2362,12 +2326,7 @@ class AuthApi:
             )
 
         else:
-            return self._oauth_callback_async_without_preload_content(
-                code=code,
-                scope=scope,
-                authuser=authuser,
-                prompt=prompt,
-                origin=origin,
+            return self._get_user_scopes_async_without_preload_content(
                 _request_timeout=_request_timeout,
                 _request_auth=_request_auth,
                 _content_type=_content_type,
@@ -2377,13 +2336,8 @@ class AuthApi:
 
     # Private async implementation methods
     @validate_call
-    async def _oauth_callback_async(
+    async def _get_user_scopes_async(
         self,
-        code: StrictStr,
-        scope: StrictStr,
-        authuser: StrictStr,
-        prompt: StrictStr,
-        origin: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -2395,21 +2349,11 @@ class AuthApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> OauthCallback200Response:
-        """OAuth Callback
+    ) -> List[str]:
+        """Get User Scopes
 
-        Handles the OAuth callback from Google.
+        Gets the scopes for the user.
 
-        :param code: (required)
-        :type code: str
-        :param scope: (required)
-        :type scope: str
-        :param authuser: (required)
-        :type authuser: str
-        :param prompt: (required)
-        :type prompt: str
-        :param origin: (required)
-        :type origin: 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
@@ -2432,12 +2376,7 @@ class AuthApi:
         :return: Returns the result object.
         """  # noqa: E501
 
-        _param = self._oauth_callback_serialize(
-            code=code,
-            scope=scope,
-            authuser=authuser,
-            prompt=prompt,
-            origin=origin,
+        _param = self._get_user_scopes_serialize(
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -2445,7 +2384,7 @@ class AuthApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            "200": "OauthCallback200Response",
+            "200": "List[str]",
         }
         response_data = await self.api_client.call_api(
             *_param, _request_timeout=_request_timeout
@@ -2457,13 +2396,8 @@ class AuthApi:
         ).data
 
     @validate_call
-    async def _oauth_callback_async_with_http_info(
+    async def _get_user_scopes_async_with_http_info(
         self,
-        code: StrictStr,
-        scope: StrictStr,
-        authuser: StrictStr,
-        prompt: StrictStr,
-        origin: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -2475,21 +2409,11 @@ class AuthApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[OauthCallback200Response]:
-        """OAuth Callback
+    ) -> ApiResponse[List[str]]:
+        """Get User Scopes
 
-        Handles the OAuth callback from Google.
+        Gets the scopes for the user.
 
-        :param code: (required)
-        :type code: str
-        :param scope: (required)
-        :type scope: str
-        :param authuser: (required)
-        :type authuser: str
-        :param prompt: (required)
-        :type prompt: str
-        :param origin: (required)
-        :type origin: 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
@@ -2512,12 +2436,7 @@ class AuthApi:
         :return: Returns the result object.
         """  # noqa: E501
 
-        _param = self._oauth_callback_serialize(
-            code=code,
-            scope=scope,
-            authuser=authuser,
-            prompt=prompt,
-            origin=origin,
+        _param = self._get_user_scopes_serialize(
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -2525,7 +2444,7 @@ class AuthApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            "200": "OauthCallback200Response",
+            "200": "List[str]",
         }
         response_data = await self.api_client.call_api(
             *_param, _request_timeout=_request_timeout
@@ -2536,13 +2455,8 @@ class AuthApi:
         )
 
     @validate_call
-    async def _oauth_callback_async_without_preload_content(
+    async def _get_user_scopes_async_without_preload_content(
         self,
-        code: StrictStr,
-        scope: StrictStr,
-        authuser: StrictStr,
-        prompt: StrictStr,
-        origin: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -2555,20 +2469,10 @@ class AuthApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """OAuth Callback
+        """Get User Scopes
 
-        Handles the OAuth callback from Google.
+        Gets the scopes for the user.
 
-        :param code: (required)
-        :type code: str
-        :param scope: (required)
-        :type scope: str
-        :param authuser: (required)
-        :type authuser: str
-        :param prompt: (required)
-        :type prompt: str
-        :param origin: (required)
-        :type origin: 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
@@ -2591,12 +2495,7 @@ class AuthApi:
         :return: Returns the result object.
         """  # noqa: E501
 
-        _param = self._oauth_callback_serialize(
-            code=code,
-            scope=scope,
-            authuser=authuser,
-            prompt=prompt,
-            origin=origin,
+        _param = self._get_user_scopes_serialize(
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -2604,7 +2503,7 @@ class AuthApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            "200": "OauthCallback200Response",
+            "200": "List[str]",
         }
         response_data = await self.api_client.call_api(
             *_param, _request_timeout=_request_timeout
@@ -2613,13 +2512,8 @@ class AuthApi:
 
     # Private sync implementation methods
     @validate_call
-    def _oauth_callback_sync(
+    def _get_user_scopes_sync(
         self,
-        code: StrictStr,
-        scope: StrictStr,
-        authuser: StrictStr,
-        prompt: StrictStr,
-        origin: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -2631,14 +2525,9 @@ class AuthApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> OauthCallback200Response:
-        """Synchronous version of oauth_callback"""
-        return async_to_sync(self._oauth_callback_async)(
-            code=code,
-            scope=scope,
-            authuser=authuser,
-            prompt=prompt,
-            origin=origin,
+    ) -> List[str]:
+        """Synchronous version of get_user_scopes"""
+        return async_to_sync(self._get_user_scopes_async)(
             _request_timeout=_request_timeout,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -2647,13 +2536,8 @@ class AuthApi:
         )
 
     @validate_call
-    def _oauth_callback_sync_with_http_info(
+    def _get_user_scopes_sync_with_http_info(
         self,
-        code: StrictStr,
-        scope: StrictStr,
-        authuser: StrictStr,
-        prompt: StrictStr,
-        origin: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -2665,14 +2549,9 @@ class AuthApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[OauthCallback200Response]:
-        """Synchronous version of oauth_callback_with_http_info"""
-        return async_to_sync(self._oauth_callback_async_with_http_info)(
-            code=code,
-            scope=scope,
-            authuser=authuser,
-            prompt=prompt,
-            origin=origin,
+    ) -> ApiResponse[List[str]]:
+        """Synchronous version of get_user_scopes_with_http_info"""
+        return async_to_sync(self._get_user_scopes_async_with_http_info)(
             _request_timeout=_request_timeout,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -2681,13 +2560,8 @@ class AuthApi:
         )
 
     @validate_call
-    def _oauth_callback_sync_without_preload_content(
+    def _get_user_scopes_sync_without_preload_content(
         self,
-        code: StrictStr,
-        scope: StrictStr,
-        authuser: StrictStr,
-        prompt: StrictStr,
-        origin: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -2700,13 +2574,8 @@ class AuthApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Synchronous version of oauth_callback_without_preload_content"""
-        return async_to_sync(self._oauth_callback_async_without_preload_content)(
-            code=code,
-            scope=scope,
-            authuser=authuser,
-            prompt=prompt,
-            origin=origin,
+        """Synchronous version of get_user_scopes_without_preload_content"""
+        return async_to_sync(self._get_user_scopes_async_without_preload_content)(
             _request_timeout=_request_timeout,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -2714,13 +2583,8 @@ class AuthApi:
             _host_index=_host_index,
         )
 
-    def _oauth_callback_serialize(
+    def _get_user_scopes_serialize(
         self,
-        code,
-        scope,
-        authuser,
-        prompt,
-        origin,
         _request_auth,
         _content_type,
         _headers,
@@ -2742,26 +2606,6 @@ class AuthApi:
 
         # process the path parameters
         # process the query parameters
-        if code is not None:
-
-            _query_params.append(("code", code))
-
-        if scope is not None:
-
-            _query_params.append(("scope", scope))
-
-        if authuser is not None:
-
-            _query_params.append(("authuser", authuser))
-
-        if prompt is not None:
-
-            _query_params.append(("prompt", prompt))
-
-        if origin is not None:
-
-            _query_params.append(("origin", origin))
-
         # process the header parameters
         # process the form parameters
         # process the body parameter
@@ -2773,11 +2617,11 @@ class AuthApi:
             )
 
         # authentication setting
-        _auth_settings: List[str] = []
+        _auth_settings: List[str] = ["HTTPBearer"]
 
         return self.api_client.param_serialize(
             method="GET",
-            resource_path="/oauth-callback",
+            resource_path="/get-user-scopes",
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -2791,12 +2635,13 @@ class AuthApi:
         )
 
     @validate_call
-    def refresh_token_info(
+    def oauth_callback(
         self,
-        x_refresh_token: Annotated[
-            Optional[StrictStr],
-            Field(description="The refresh token for rotating the access token."),
-        ] = None,
+        code: StrictStr,
+        scope: StrictStr,
+        authuser: StrictStr,
+        prompt: StrictStr,
+        origin: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -2808,11 +2653,15 @@ class AuthApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> RefreshTokenInfo200Response:
-        """Refresh token info"""
+    ) -> OauthCallback200Response:
+        """OAuth Callback"""
         if self.is_sync:
-            return self._refresh_token_info_sync(
-                x_refresh_token=x_refresh_token,
+            return self._oauth_callback_sync(
+                code=code,
+                scope=scope,
+                authuser=authuser,
+                prompt=prompt,
+                origin=origin,
                 _request_timeout=_request_timeout,
                 _request_auth=_request_auth,
                 _content_type=_content_type,
@@ -2821,8 +2670,12 @@ class AuthApi:
             )
 
         else:
-            return self._refresh_token_info_async(
-                x_refresh_token=x_refresh_token,
+            return self._oauth_callback_async(
+                code=code,
+                scope=scope,
+                authuser=authuser,
+                prompt=prompt,
+                origin=origin,
                 _request_timeout=_request_timeout,
                 _request_auth=_request_auth,
                 _content_type=_content_type,
@@ -2831,12 +2684,13 @@ class AuthApi:
             )
 
     @validate_call
-    def refresh_token_info_with_http_info(
+    def oauth_callback_with_http_info(
         self,
-        x_refresh_token: Annotated[
-            Optional[StrictStr],
-            Field(description="The refresh token for rotating the access token."),
-        ] = None,
+        code: StrictStr,
+        scope: StrictStr,
+        authuser: StrictStr,
+        prompt: StrictStr,
+        origin: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -2848,12 +2702,983 @@ class AuthApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[RefreshTokenInfo200Response]:
-        """Refresh token info with HTTP info"""
+    ) -> ApiResponse[OauthCallback200Response]:
+        """OAuth Callback with HTTP info"""
         if self.is_sync:
-            return self._refresh_token_info_sync_with_http_info(
-                x_refresh_token=x_refresh_token,
-                _request_timeout=_request_timeout,
+            return self._oauth_callback_sync_with_http_info(
+                code=code,
+                scope=scope,
+                authuser=authuser,
+                prompt=prompt,
+                origin=origin,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+        else:
+            return self._oauth_callback_async_with_http_info(
+                code=code,
+                scope=scope,
+                authuser=authuser,
+                prompt=prompt,
+                origin=origin,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+    @validate_call
+    def oauth_callback_without_preload_content(
+        self,
+        code: StrictStr,
+        scope: StrictStr,
+        authuser: StrictStr,
+        prompt: StrictStr,
+        origin: StrictStr,
+        _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:
+        """OAuth Callback without preloading content"""
+        if self.is_sync:
+            return self._oauth_callback_sync_without_preload_content(
+                code=code,
+                scope=scope,
+                authuser=authuser,
+                prompt=prompt,
+                origin=origin,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+        else:
+            return self._oauth_callback_async_without_preload_content(
+                code=code,
+                scope=scope,
+                authuser=authuser,
+                prompt=prompt,
+                origin=origin,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+    # Private async implementation methods
+    @validate_call
+    async def _oauth_callback_async(
+        self,
+        code: StrictStr,
+        scope: StrictStr,
+        authuser: StrictStr,
+        prompt: StrictStr,
+        origin: StrictStr,
+        _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,
+    ) -> OauthCallback200Response:
+        """OAuth Callback
+
+        Handles the OAuth callback from Google.
+
+        :param code: (required)
+        :type code: str
+        :param scope: (required)
+        :type scope: str
+        :param authuser: (required)
+        :type authuser: str
+        :param prompt: (required)
+        :type prompt: str
+        :param origin: (required)
+        :type origin: 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._oauth_callback_serialize(
+            code=code,
+            scope=scope,
+            authuser=authuser,
+            prompt=prompt,
+            origin=origin,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            "200": "OauthCallback200Response",
+        }
+        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 _oauth_callback_async_with_http_info(
+        self,
+        code: StrictStr,
+        scope: StrictStr,
+        authuser: StrictStr,
+        prompt: StrictStr,
+        origin: StrictStr,
+        _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[OauthCallback200Response]:
+        """OAuth Callback
+
+        Handles the OAuth callback from Google.
+
+        :param code: (required)
+        :type code: str
+        :param scope: (required)
+        :type scope: str
+        :param authuser: (required)
+        :type authuser: str
+        :param prompt: (required)
+        :type prompt: str
+        :param origin: (required)
+        :type origin: 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._oauth_callback_serialize(
+            code=code,
+            scope=scope,
+            authuser=authuser,
+            prompt=prompt,
+            origin=origin,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            "200": "OauthCallback200Response",
+        }
+        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 _oauth_callback_async_without_preload_content(
+        self,
+        code: StrictStr,
+        scope: StrictStr,
+        authuser: StrictStr,
+        prompt: StrictStr,
+        origin: StrictStr,
+        _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:
+        """OAuth Callback
+
+        Handles the OAuth callback from Google.
+
+        :param code: (required)
+        :type code: str
+        :param scope: (required)
+        :type scope: str
+        :param authuser: (required)
+        :type authuser: str
+        :param prompt: (required)
+        :type prompt: str
+        :param origin: (required)
+        :type origin: 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._oauth_callback_serialize(
+            code=code,
+            scope=scope,
+            authuser=authuser,
+            prompt=prompt,
+            origin=origin,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            "200": "OauthCallback200Response",
+        }
+        response_data = await self.api_client.call_api(
+            *_param, _request_timeout=_request_timeout
+        )
+        return response_data
+
+    # Private sync implementation methods
+    @validate_call
+    def _oauth_callback_sync(
+        self,
+        code: StrictStr,
+        scope: StrictStr,
+        authuser: StrictStr,
+        prompt: StrictStr,
+        origin: StrictStr,
+        _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,
+    ) -> OauthCallback200Response:
+        """Synchronous version of oauth_callback"""
+        return async_to_sync(self._oauth_callback_async)(
+            code=code,
+            scope=scope,
+            authuser=authuser,
+            prompt=prompt,
+            origin=origin,
+            _request_timeout=_request_timeout,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+    @validate_call
+    def _oauth_callback_sync_with_http_info(
+        self,
+        code: StrictStr,
+        scope: StrictStr,
+        authuser: StrictStr,
+        prompt: StrictStr,
+        origin: StrictStr,
+        _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[OauthCallback200Response]:
+        """Synchronous version of oauth_callback_with_http_info"""
+        return async_to_sync(self._oauth_callback_async_with_http_info)(
+            code=code,
+            scope=scope,
+            authuser=authuser,
+            prompt=prompt,
+            origin=origin,
+            _request_timeout=_request_timeout,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+    @validate_call
+    def _oauth_callback_sync_without_preload_content(
+        self,
+        code: StrictStr,
+        scope: StrictStr,
+        authuser: StrictStr,
+        prompt: StrictStr,
+        origin: StrictStr,
+        _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:
+        """Synchronous version of oauth_callback_without_preload_content"""
+        return async_to_sync(self._oauth_callback_async_without_preload_content)(
+            code=code,
+            scope=scope,
+            authuser=authuser,
+            prompt=prompt,
+            origin=origin,
+            _request_timeout=_request_timeout,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+    def _oauth_callback_serialize(
+        self,
+        code,
+        scope,
+        authuser,
+        prompt,
+        origin,
+        _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
+        if code is not None:
+
+            _query_params.append(("code", code))
+
+        if scope is not None:
+
+            _query_params.append(("scope", scope))
+
+        if authuser is not None:
+
+            _query_params.append(("authuser", authuser))
+
+        if prompt is not None:
+
+            _query_params.append(("prompt", prompt))
+
+        if origin is not None:
+
+            _query_params.append(("origin", origin))
+
+        # 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] = []
+
+        return self.api_client.param_serialize(
+            method="GET",
+            resource_path="/oauth-callback",
+            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
+    def refresh_token_info(
+        self,
+        x_refresh_token: Annotated[
+            Optional[StrictStr],
+            Field(description="The refresh token for rotating the access token."),
+        ] = 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,
+    ) -> RefreshTokenInfo200Response:
+        """Refresh token info"""
+        if self.is_sync:
+            return self._refresh_token_info_sync(
+                x_refresh_token=x_refresh_token,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+        else:
+            return self._refresh_token_info_async(
+                x_refresh_token=x_refresh_token,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+    @validate_call
+    def refresh_token_info_with_http_info(
+        self,
+        x_refresh_token: Annotated[
+            Optional[StrictStr],
+            Field(description="The refresh token for rotating the access token."),
+        ] = 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[RefreshTokenInfo200Response]:
+        """Refresh token info with HTTP info"""
+        if self.is_sync:
+            return self._refresh_token_info_sync_with_http_info(
+                x_refresh_token=x_refresh_token,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+        else:
+            return self._refresh_token_info_async_with_http_info(
+                x_refresh_token=x_refresh_token,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+    @validate_call
+    def refresh_token_info_without_preload_content(
+        self,
+        x_refresh_token: Annotated[
+            Optional[StrictStr],
+            Field(description="The refresh token for rotating the access token."),
+        ] = 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:
+        """Refresh token info without preloading content"""
+        if self.is_sync:
+            return self._refresh_token_info_sync_without_preload_content(
+                x_refresh_token=x_refresh_token,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+        else:
+            return self._refresh_token_info_async_without_preload_content(
+                x_refresh_token=x_refresh_token,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+    # Private async implementation methods
+    @validate_call
+    async def _refresh_token_info_async(
+        self,
+        x_refresh_token: Annotated[
+            Optional[StrictStr],
+            Field(description="The refresh token for rotating the access token."),
+        ] = 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,
+    ) -> RefreshTokenInfo200Response:
+        """Refresh token info
+
+        Returns the user session record of the refresh token.
+
+        :param x_refresh_token: The refresh token for rotating the access token.
+        :type x_refresh_token: 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._refresh_token_info_serialize(
+            x_refresh_token=x_refresh_token,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            "200": "RefreshTokenInfo200Response",
+        }
+        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 _refresh_token_info_async_with_http_info(
+        self,
+        x_refresh_token: Annotated[
+            Optional[StrictStr],
+            Field(description="The refresh token for rotating the access token."),
+        ] = 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[RefreshTokenInfo200Response]:
+        """Refresh token info
+
+        Returns the user session record of the refresh token.
+
+        :param x_refresh_token: The refresh token for rotating the access token.
+        :type x_refresh_token: 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._refresh_token_info_serialize(
+            x_refresh_token=x_refresh_token,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            "200": "RefreshTokenInfo200Response",
+        }
+        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 _refresh_token_info_async_without_preload_content(
+        self,
+        x_refresh_token: Annotated[
+            Optional[StrictStr],
+            Field(description="The refresh token for rotating the access token."),
+        ] = 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:
+        """Refresh token info
+
+        Returns the user session record of the refresh token.
+
+        :param x_refresh_token: The refresh token for rotating the access token.
+        :type x_refresh_token: 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._refresh_token_info_serialize(
+            x_refresh_token=x_refresh_token,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            "200": "RefreshTokenInfo200Response",
+        }
+        response_data = await self.api_client.call_api(
+            *_param, _request_timeout=_request_timeout
+        )
+        return response_data
+
+    # Private sync implementation methods
+    @validate_call
+    def _refresh_token_info_sync(
+        self,
+        x_refresh_token: Annotated[
+            Optional[StrictStr],
+            Field(description="The refresh token for rotating the access token."),
+        ] = 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,
+    ) -> RefreshTokenInfo200Response:
+        """Synchronous version of refresh_token_info"""
+        return async_to_sync(self._refresh_token_info_async)(
+            x_refresh_token=x_refresh_token,
+            _request_timeout=_request_timeout,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+    @validate_call
+    def _refresh_token_info_sync_with_http_info(
+        self,
+        x_refresh_token: Annotated[
+            Optional[StrictStr],
+            Field(description="The refresh token for rotating the access token."),
+        ] = 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[RefreshTokenInfo200Response]:
+        """Synchronous version of refresh_token_info_with_http_info"""
+        return async_to_sync(self._refresh_token_info_async_with_http_info)(
+            x_refresh_token=x_refresh_token,
+            _request_timeout=_request_timeout,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+    @validate_call
+    def _refresh_token_info_sync_without_preload_content(
+        self,
+        x_refresh_token: Annotated[
+            Optional[StrictStr],
+            Field(description="The refresh token for rotating the access token."),
+        ] = 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:
+        """Synchronous version of refresh_token_info_without_preload_content"""
+        return async_to_sync(self._refresh_token_info_async_without_preload_content)(
+            x_refresh_token=x_refresh_token,
+            _request_timeout=_request_timeout,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+    def _refresh_token_info_serialize(
+        self,
+        x_refresh_token,
+        _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
+        if x_refresh_token is not None:
+            _header_params["X-Refresh-Token"] = x_refresh_token
+        # 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] = []
+
+        return self.api_client.param_serialize(
+            method="GET",
+            resource_path="/refresh-token-info",
+            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
+    def refresh_token_scopes(
+        self,
+        x_refresh_token: Annotated[
+            Optional[StrictStr],
+            Field(description="The refresh token for rotating the access token."),
+        ] = 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,
+    ) -> RotateTokens200Response:
+        """Refresh token scopes"""
+        if self.is_sync:
+            return self._refresh_token_scopes_sync(
+                x_refresh_token=x_refresh_token,
+                _request_timeout=_request_timeout,
                 _request_auth=_request_auth,
                 _content_type=_content_type,
                 _headers=_headers,
@@ -2861,7 +3686,7 @@ class AuthApi:
             )
 
         else:
-            return self._refresh_token_info_async_with_http_info(
+            return self._refresh_token_scopes_async(
                 x_refresh_token=x_refresh_token,
                 _request_timeout=_request_timeout,
                 _request_auth=_request_auth,
@@ -2871,7 +3696,47 @@ class AuthApi:
             )
 
     @validate_call
-    def refresh_token_info_without_preload_content(
+    def refresh_token_scopes_with_http_info(
+        self,
+        x_refresh_token: Annotated[
+            Optional[StrictStr],
+            Field(description="The refresh token for rotating the access token."),
+        ] = 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[RotateTokens200Response]:
+        """Refresh token scopes with HTTP info"""
+        if self.is_sync:
+            return self._refresh_token_scopes_sync_with_http_info(
+                x_refresh_token=x_refresh_token,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+        else:
+            return self._refresh_token_scopes_async_with_http_info(
+                x_refresh_token=x_refresh_token,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+    @validate_call
+    def refresh_token_scopes_without_preload_content(
         self,
         x_refresh_token: Annotated[
             Optional[StrictStr],
@@ -2889,9 +3754,9 @@ class AuthApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Refresh token info without preloading content"""
+        """Refresh token scopes without preloading content"""
         if self.is_sync:
-            return self._refresh_token_info_sync_without_preload_content(
+            return self._refresh_token_scopes_sync_without_preload_content(
                 x_refresh_token=x_refresh_token,
                 _request_timeout=_request_timeout,
                 _request_auth=_request_auth,
@@ -2901,7 +3766,7 @@ class AuthApi:
             )
 
         else:
-            return self._refresh_token_info_async_without_preload_content(
+            return self._refresh_token_scopes_async_without_preload_content(
                 x_refresh_token=x_refresh_token,
                 _request_timeout=_request_timeout,
                 _request_auth=_request_auth,
@@ -2912,7 +3777,7 @@ class AuthApi:
 
     # Private async implementation methods
     @validate_call
-    async def _refresh_token_info_async(
+    async def _refresh_token_scopes_async(
         self,
         x_refresh_token: Annotated[
             Optional[StrictStr],
@@ -2929,10 +3794,10 @@ class AuthApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> RefreshTokenInfo200Response:
-        """Refresh token info
+    ) -> RotateTokens200Response:
+        """Refresh token scopes
 
-        Returns the user session record of the refresh token.
+        Refresh token scopes for a given user and a valid access token and a valid refresh token. This manually re-creates the access token with the latest scopes, in case the user changed their subscription status, access to certain features.
 
         :param x_refresh_token: The refresh token for rotating the access token.
         :type x_refresh_token: str
@@ -2958,7 +3823,7 @@ class AuthApi:
         :return: Returns the result object.
         """  # noqa: E501
 
-        _param = self._refresh_token_info_serialize(
+        _param = self._refresh_token_scopes_serialize(
             x_refresh_token=x_refresh_token,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -2967,7 +3832,7 @@ class AuthApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            "200": "RefreshTokenInfo200Response",
+            "200": "RotateTokens200Response",
         }
         response_data = await self.api_client.call_api(
             *_param, _request_timeout=_request_timeout
@@ -2979,7 +3844,7 @@ class AuthApi:
         ).data
 
     @validate_call
-    async def _refresh_token_info_async_with_http_info(
+    async def _refresh_token_scopes_async_with_http_info(
         self,
         x_refresh_token: Annotated[
             Optional[StrictStr],
@@ -2996,10 +3861,10 @@ class AuthApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[RefreshTokenInfo200Response]:
-        """Refresh token info
+    ) -> ApiResponse[RotateTokens200Response]:
+        """Refresh token scopes
 
-        Returns the user session record of the refresh token.
+        Refresh token scopes for a given user and a valid access token and a valid refresh token. This manually re-creates the access token with the latest scopes, in case the user changed their subscription status, access to certain features.
 
         :param x_refresh_token: The refresh token for rotating the access token.
         :type x_refresh_token: str
@@ -3025,7 +3890,7 @@ class AuthApi:
         :return: Returns the result object.
         """  # noqa: E501
 
-        _param = self._refresh_token_info_serialize(
+        _param = self._refresh_token_scopes_serialize(
             x_refresh_token=x_refresh_token,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -3034,7 +3899,7 @@ class AuthApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            "200": "RefreshTokenInfo200Response",
+            "200": "RotateTokens200Response",
         }
         response_data = await self.api_client.call_api(
             *_param, _request_timeout=_request_timeout
@@ -3045,7 +3910,7 @@ class AuthApi:
         )
 
     @validate_call
-    async def _refresh_token_info_async_without_preload_content(
+    async def _refresh_token_scopes_async_without_preload_content(
         self,
         x_refresh_token: Annotated[
             Optional[StrictStr],
@@ -3063,9 +3928,9 @@ class AuthApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Refresh token info
+        """Refresh token scopes
 
-        Returns the user session record of the refresh token.
+        Refresh token scopes for a given user and a valid access token and a valid refresh token. This manually re-creates the access token with the latest scopes, in case the user changed their subscription status, access to certain features.
 
         :param x_refresh_token: The refresh token for rotating the access token.
         :type x_refresh_token: str
@@ -3091,7 +3956,7 @@ class AuthApi:
         :return: Returns the result object.
         """  # noqa: E501
 
-        _param = self._refresh_token_info_serialize(
+        _param = self._refresh_token_scopes_serialize(
             x_refresh_token=x_refresh_token,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -3100,7 +3965,7 @@ class AuthApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            "200": "RefreshTokenInfo200Response",
+            "200": "RotateTokens200Response",
         }
         response_data = await self.api_client.call_api(
             *_param, _request_timeout=_request_timeout
@@ -3109,7 +3974,7 @@ class AuthApi:
 
     # Private sync implementation methods
     @validate_call
-    def _refresh_token_info_sync(
+    def _refresh_token_scopes_sync(
         self,
         x_refresh_token: Annotated[
             Optional[StrictStr],
@@ -3126,9 +3991,9 @@ class AuthApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> RefreshTokenInfo200Response:
-        """Synchronous version of refresh_token_info"""
-        return async_to_sync(self._refresh_token_info_async)(
+    ) -> RotateTokens200Response:
+        """Synchronous version of refresh_token_scopes"""
+        return async_to_sync(self._refresh_token_scopes_async)(
             x_refresh_token=x_refresh_token,
             _request_timeout=_request_timeout,
             _request_auth=_request_auth,
@@ -3138,7 +4003,7 @@ class AuthApi:
         )
 
     @validate_call
-    def _refresh_token_info_sync_with_http_info(
+    def _refresh_token_scopes_sync_with_http_info(
         self,
         x_refresh_token: Annotated[
             Optional[StrictStr],
@@ -3155,9 +4020,9 @@ class AuthApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[RefreshTokenInfo200Response]:
-        """Synchronous version of refresh_token_info_with_http_info"""
-        return async_to_sync(self._refresh_token_info_async_with_http_info)(
+    ) -> ApiResponse[RotateTokens200Response]:
+        """Synchronous version of refresh_token_scopes_with_http_info"""
+        return async_to_sync(self._refresh_token_scopes_async_with_http_info)(
             x_refresh_token=x_refresh_token,
             _request_timeout=_request_timeout,
             _request_auth=_request_auth,
@@ -3167,7 +4032,7 @@ class AuthApi:
         )
 
     @validate_call
-    def _refresh_token_info_sync_without_preload_content(
+    def _refresh_token_scopes_sync_without_preload_content(
         self,
         x_refresh_token: Annotated[
             Optional[StrictStr],
@@ -3185,8 +4050,8 @@ class AuthApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Synchronous version of refresh_token_info_without_preload_content"""
-        return async_to_sync(self._refresh_token_info_async_without_preload_content)(
+        """Synchronous version of refresh_token_scopes_without_preload_content"""
+        return async_to_sync(self._refresh_token_scopes_async_without_preload_content)(
             x_refresh_token=x_refresh_token,
             _request_timeout=_request_timeout,
             _request_auth=_request_auth,
@@ -3195,7 +4060,7 @@ class AuthApi:
             _host_index=_host_index,
         )
 
-    def _refresh_token_info_serialize(
+    def _refresh_token_scopes_serialize(
         self,
         x_refresh_token,
         _request_auth,
@@ -3235,8 +4100,8 @@ class AuthApi:
         _auth_settings: List[str] = []
 
         return self.api_client.param_serialize(
-            method="GET",
-            resource_path="/refresh-token-info",
+            method="POST",
+            resource_path="/refresh-token-scopes",
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -3250,7 +4115,7 @@ class AuthApi:
         )
 
     @validate_call
-    def refresh_token_scopes(
+    def rotate_tokens(
         self,
         x_refresh_token: Annotated[
             Optional[StrictStr],
@@ -3268,9 +4133,9 @@ class AuthApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RotateTokens200Response:
-        """Refresh token scopes"""
+        """Rotate tokens"""
         if self.is_sync:
-            return self._refresh_token_scopes_sync(
+            return self._rotate_tokens_sync(
                 x_refresh_token=x_refresh_token,
                 _request_timeout=_request_timeout,
                 _request_auth=_request_auth,
@@ -3280,7 +4145,7 @@ class AuthApi:
             )
 
         else:
-            return self._refresh_token_scopes_async(
+            return self._rotate_tokens_async(
                 x_refresh_token=x_refresh_token,
                 _request_timeout=_request_timeout,
                 _request_auth=_request_auth,
@@ -3290,7 +4155,7 @@ class AuthApi:
             )
 
     @validate_call
-    def refresh_token_scopes_with_http_info(
+    def rotate_tokens_with_http_info(
         self,
         x_refresh_token: Annotated[
             Optional[StrictStr],
@@ -3308,9 +4173,9 @@ class AuthApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> ApiResponse[RotateTokens200Response]:
-        """Refresh token scopes with HTTP info"""
+        """Rotate tokens with HTTP info"""
         if self.is_sync:
-            return self._refresh_token_scopes_sync_with_http_info(
+            return self._rotate_tokens_sync_with_http_info(
                 x_refresh_token=x_refresh_token,
                 _request_timeout=_request_timeout,
                 _request_auth=_request_auth,
@@ -3320,7 +4185,7 @@ class AuthApi:
             )
 
         else:
-            return self._refresh_token_scopes_async_with_http_info(
+            return self._rotate_tokens_async_with_http_info(
                 x_refresh_token=x_refresh_token,
                 _request_timeout=_request_timeout,
                 _request_auth=_request_auth,
@@ -3330,7 +4195,7 @@ class AuthApi:
             )
 
     @validate_call
-    def refresh_token_scopes_without_preload_content(
+    def rotate_tokens_without_preload_content(
         self,
         x_refresh_token: Annotated[
             Optional[StrictStr],
@@ -3348,9 +4213,9 @@ class AuthApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Refresh token scopes without preloading content"""
+        """Rotate tokens without preloading content"""
         if self.is_sync:
-            return self._refresh_token_scopes_sync_without_preload_content(
+            return self._rotate_tokens_sync_without_preload_content(
                 x_refresh_token=x_refresh_token,
                 _request_timeout=_request_timeout,
                 _request_auth=_request_auth,
@@ -3360,7 +4225,7 @@ class AuthApi:
             )
 
         else:
-            return self._refresh_token_scopes_async_without_preload_content(
+            return self._rotate_tokens_async_without_preload_content(
                 x_refresh_token=x_refresh_token,
                 _request_timeout=_request_timeout,
                 _request_auth=_request_auth,
@@ -3371,7 +4236,7 @@ class AuthApi:
 
     # Private async implementation methods
     @validate_call
-    async def _refresh_token_scopes_async(
+    async def _rotate_tokens_async(
         self,
         x_refresh_token: Annotated[
             Optional[StrictStr],
@@ -3389,9 +4254,9 @@ class AuthApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RotateTokens200Response:
-        """Refresh token scopes
+        """Rotate tokens
 
-        Refresh token scopes for a given user and a valid access token and a valid refresh token. This manually re-creates the access token with the latest scopes, in case the user changed their subscription status, access to certain features.
+        Handles token rotation for user authentication. If access token is expired: Uses refresh token to generate a new access token. If access token is still valid: Extends (slides) the current token's expiration date. Returns both updated access and refresh tokens.
 
         :param x_refresh_token: The refresh token for rotating the access token.
         :type x_refresh_token: str
@@ -3417,7 +4282,7 @@ class AuthApi:
         :return: Returns the result object.
         """  # noqa: E501
 
-        _param = self._refresh_token_scopes_serialize(
+        _param = self._rotate_tokens_serialize(
             x_refresh_token=x_refresh_token,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -3438,7 +4303,7 @@ class AuthApi:
         ).data
 
     @validate_call
-    async def _refresh_token_scopes_async_with_http_info(
+    async def _rotate_tokens_async_with_http_info(
         self,
         x_refresh_token: Annotated[
             Optional[StrictStr],
@@ -3456,9 +4321,9 @@ class AuthApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> ApiResponse[RotateTokens200Response]:
-        """Refresh token scopes
+        """Rotate tokens
 
-        Refresh token scopes for a given user and a valid access token and a valid refresh token. This manually re-creates the access token with the latest scopes, in case the user changed their subscription status, access to certain features.
+        Handles token rotation for user authentication. If access token is expired: Uses refresh token to generate a new access token. If access token is still valid: Extends (slides) the current token's expiration date. Returns both updated access and refresh tokens.
 
         :param x_refresh_token: The refresh token for rotating the access token.
         :type x_refresh_token: str
@@ -3484,7 +4349,7 @@ class AuthApi:
         :return: Returns the result object.
         """  # noqa: E501
 
-        _param = self._refresh_token_scopes_serialize(
+        _param = self._rotate_tokens_serialize(
             x_refresh_token=x_refresh_token,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -3504,7 +4369,7 @@ class AuthApi:
         )
 
     @validate_call
-    async def _refresh_token_scopes_async_without_preload_content(
+    async def _rotate_tokens_async_without_preload_content(
         self,
         x_refresh_token: Annotated[
             Optional[StrictStr],
@@ -3522,9 +4387,9 @@ class AuthApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Refresh token scopes
+        """Rotate tokens
 
-        Refresh token scopes for a given user and a valid access token and a valid refresh token. This manually re-creates the access token with the latest scopes, in case the user changed their subscription status, access to certain features.
+        Handles token rotation for user authentication. If access token is expired: Uses refresh token to generate a new access token. If access token is still valid: Extends (slides) the current token's expiration date. Returns both updated access and refresh tokens.
 
         :param x_refresh_token: The refresh token for rotating the access token.
         :type x_refresh_token: str
@@ -3550,7 +4415,7 @@ class AuthApi:
         :return: Returns the result object.
         """  # noqa: E501
 
-        _param = self._refresh_token_scopes_serialize(
+        _param = self._rotate_tokens_serialize(
             x_refresh_token=x_refresh_token,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -3568,7 +4433,7 @@ class AuthApi:
 
     # Private sync implementation methods
     @validate_call
-    def _refresh_token_scopes_sync(
+    def _rotate_tokens_sync(
         self,
         x_refresh_token: Annotated[
             Optional[StrictStr],
@@ -3586,8 +4451,8 @@ class AuthApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RotateTokens200Response:
-        """Synchronous version of refresh_token_scopes"""
-        return async_to_sync(self._refresh_token_scopes_async)(
+        """Synchronous version of rotate_tokens"""
+        return async_to_sync(self._rotate_tokens_async)(
             x_refresh_token=x_refresh_token,
             _request_timeout=_request_timeout,
             _request_auth=_request_auth,
@@ -3597,7 +4462,7 @@ class AuthApi:
         )
 
     @validate_call
-    def _refresh_token_scopes_sync_with_http_info(
+    def _rotate_tokens_sync_with_http_info(
         self,
         x_refresh_token: Annotated[
             Optional[StrictStr],
@@ -3615,8 +4480,8 @@ class AuthApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> ApiResponse[RotateTokens200Response]:
-        """Synchronous version of refresh_token_scopes_with_http_info"""
-        return async_to_sync(self._refresh_token_scopes_async_with_http_info)(
+        """Synchronous version of rotate_tokens_with_http_info"""
+        return async_to_sync(self._rotate_tokens_async_with_http_info)(
             x_refresh_token=x_refresh_token,
             _request_timeout=_request_timeout,
             _request_auth=_request_auth,
@@ -3626,7 +4491,7 @@ class AuthApi:
         )
 
     @validate_call
-    def _refresh_token_scopes_sync_without_preload_content(
+    def _rotate_tokens_sync_without_preload_content(
         self,
         x_refresh_token: Annotated[
             Optional[StrictStr],
@@ -3644,8 +4509,8 @@ class AuthApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Synchronous version of refresh_token_scopes_without_preload_content"""
-        return async_to_sync(self._refresh_token_scopes_async_without_preload_content)(
+        """Synchronous version of rotate_tokens_without_preload_content"""
+        return async_to_sync(self._rotate_tokens_async_without_preload_content)(
             x_refresh_token=x_refresh_token,
             _request_timeout=_request_timeout,
             _request_auth=_request_auth,
@@ -3654,7 +4519,7 @@ class AuthApi:
             _host_index=_host_index,
         )
 
-    def _refresh_token_scopes_serialize(
+    def _rotate_tokens_serialize(
         self,
         x_refresh_token,
         _request_auth,
@@ -3695,7 +4560,7 @@ class AuthApi:
 
         return self.api_client.param_serialize(
             method="POST",
-            resource_path="/refresh-token-scopes",
+            resource_path="/rotate-tokens",
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -3709,7 +4574,7 @@ class AuthApi:
         )
 
     @validate_call
-    def rotate_tokens(
+    def token_info(
         self,
         x_refresh_token: Annotated[
             Optional[StrictStr],
@@ -3726,10 +4591,10 @@ class AuthApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> RotateTokens200Response:
-        """Rotate tokens"""
+    ) -> TokenInfo200Response:
+        """Token info"""
         if self.is_sync:
-            return self._rotate_tokens_sync(
+            return self._token_info_sync(
                 x_refresh_token=x_refresh_token,
                 _request_timeout=_request_timeout,
                 _request_auth=_request_auth,
@@ -3739,7 +4604,7 @@ class AuthApi:
             )
 
         else:
-            return self._rotate_tokens_async(
+            return self._token_info_async(
                 x_refresh_token=x_refresh_token,
                 _request_timeout=_request_timeout,
                 _request_auth=_request_auth,
@@ -3749,7 +4614,7 @@ class AuthApi:
             )
 
     @validate_call
-    def rotate_tokens_with_http_info(
+    def token_info_with_http_info(
         self,
         x_refresh_token: Annotated[
             Optional[StrictStr],
@@ -3766,10 +4631,10 @@ class AuthApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[RotateTokens200Response]:
-        """Rotate tokens with HTTP info"""
+    ) -> ApiResponse[TokenInfo200Response]:
+        """Token info with HTTP info"""
         if self.is_sync:
-            return self._rotate_tokens_sync_with_http_info(
+            return self._token_info_sync_with_http_info(
                 x_refresh_token=x_refresh_token,
                 _request_timeout=_request_timeout,
                 _request_auth=_request_auth,
@@ -3779,7 +4644,7 @@ class AuthApi:
             )
 
         else:
-            return self._rotate_tokens_async_with_http_info(
+            return self._token_info_async_with_http_info(
                 x_refresh_token=x_refresh_token,
                 _request_timeout=_request_timeout,
                 _request_auth=_request_auth,
@@ -3789,7 +4654,7 @@ class AuthApi:
             )
 
     @validate_call
-    def rotate_tokens_without_preload_content(
+    def token_info_without_preload_content(
         self,
         x_refresh_token: Annotated[
             Optional[StrictStr],
@@ -3807,9 +4672,9 @@ class AuthApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Rotate tokens without preloading content"""
+        """Token info without preloading content"""
         if self.is_sync:
-            return self._rotate_tokens_sync_without_preload_content(
+            return self._token_info_sync_without_preload_content(
                 x_refresh_token=x_refresh_token,
                 _request_timeout=_request_timeout,
                 _request_auth=_request_auth,
@@ -3819,7 +4684,7 @@ class AuthApi:
             )
 
         else:
-            return self._rotate_tokens_async_without_preload_content(
+            return self._token_info_async_without_preload_content(
                 x_refresh_token=x_refresh_token,
                 _request_timeout=_request_timeout,
                 _request_auth=_request_auth,
@@ -3830,7 +4695,7 @@ class AuthApi:
 
     # Private async implementation methods
     @validate_call
-    async def _rotate_tokens_async(
+    async def _token_info_async(
         self,
         x_refresh_token: Annotated[
             Optional[StrictStr],
@@ -3847,10 +4712,10 @@ class AuthApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> RotateTokens200Response:
-        """Rotate tokens
+    ) -> TokenInfo200Response:
+        """Token info
 
-        Handles token rotation for user authentication. If access token is expired: Uses refresh token to generate a new access token. If access token is still valid: Extends (slides) the current token's expiration date. Returns both updated access and refresh tokens.
+        Returns the payload of the access token.
 
         :param x_refresh_token: The refresh token for rotating the access token.
         :type x_refresh_token: str
@@ -3876,7 +4741,7 @@ class AuthApi:
         :return: Returns the result object.
         """  # noqa: E501
 
-        _param = self._rotate_tokens_serialize(
+        _param = self._token_info_serialize(
             x_refresh_token=x_refresh_token,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -3885,7 +4750,7 @@ class AuthApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            "200": "RotateTokens200Response",
+            "200": "TokenInfo200Response",
         }
         response_data = await self.api_client.call_api(
             *_param, _request_timeout=_request_timeout
@@ -3897,7 +4762,7 @@ class AuthApi:
         ).data
 
     @validate_call
-    async def _rotate_tokens_async_with_http_info(
+    async def _token_info_async_with_http_info(
         self,
         x_refresh_token: Annotated[
             Optional[StrictStr],
@@ -3914,10 +4779,10 @@ class AuthApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[RotateTokens200Response]:
-        """Rotate tokens
+    ) -> ApiResponse[TokenInfo200Response]:
+        """Token info
 
-        Handles token rotation for user authentication. If access token is expired: Uses refresh token to generate a new access token. If access token is still valid: Extends (slides) the current token's expiration date. Returns both updated access and refresh tokens.
+        Returns the payload of the access token.
 
         :param x_refresh_token: The refresh token for rotating the access token.
         :type x_refresh_token: str
@@ -3943,7 +4808,7 @@ class AuthApi:
         :return: Returns the result object.
         """  # noqa: E501
 
-        _param = self._rotate_tokens_serialize(
+        _param = self._token_info_serialize(
             x_refresh_token=x_refresh_token,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -3952,7 +4817,7 @@ class AuthApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            "200": "RotateTokens200Response",
+            "200": "TokenInfo200Response",
         }
         response_data = await self.api_client.call_api(
             *_param, _request_timeout=_request_timeout
@@ -3963,7 +4828,7 @@ class AuthApi:
         )
 
     @validate_call
-    async def _rotate_tokens_async_without_preload_content(
+    async def _token_info_async_without_preload_content(
         self,
         x_refresh_token: Annotated[
             Optional[StrictStr],
@@ -3981,9 +4846,9 @@ class AuthApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Rotate tokens
+        """Token info
 
-        Handles token rotation for user authentication. If access token is expired: Uses refresh token to generate a new access token. If access token is still valid: Extends (slides) the current token's expiration date. Returns both updated access and refresh tokens.
+        Returns the payload of the access token.
 
         :param x_refresh_token: The refresh token for rotating the access token.
         :type x_refresh_token: str
@@ -4009,7 +4874,7 @@ class AuthApi:
         :return: Returns the result object.
         """  # noqa: E501
 
-        _param = self._rotate_tokens_serialize(
+        _param = self._token_info_serialize(
             x_refresh_token=x_refresh_token,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -4018,7 +4883,7 @@ class AuthApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            "200": "RotateTokens200Response",
+            "200": "TokenInfo200Response",
         }
         response_data = await self.api_client.call_api(
             *_param, _request_timeout=_request_timeout
@@ -4027,7 +4892,7 @@ class AuthApi:
 
     # Private sync implementation methods
     @validate_call
-    def _rotate_tokens_sync(
+    def _token_info_sync(
         self,
         x_refresh_token: Annotated[
             Optional[StrictStr],
@@ -4044,9 +4909,9 @@ class AuthApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> RotateTokens200Response:
-        """Synchronous version of rotate_tokens"""
-        return async_to_sync(self._rotate_tokens_async)(
+    ) -> TokenInfo200Response:
+        """Synchronous version of token_info"""
+        return async_to_sync(self._token_info_async)(
             x_refresh_token=x_refresh_token,
             _request_timeout=_request_timeout,
             _request_auth=_request_auth,
@@ -4056,7 +4921,7 @@ class AuthApi:
         )
 
     @validate_call
-    def _rotate_tokens_sync_with_http_info(
+    def _token_info_sync_with_http_info(
         self,
         x_refresh_token: Annotated[
             Optional[StrictStr],
@@ -4073,9 +4938,9 @@ class AuthApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[RotateTokens200Response]:
-        """Synchronous version of rotate_tokens_with_http_info"""
-        return async_to_sync(self._rotate_tokens_async_with_http_info)(
+    ) -> ApiResponse[TokenInfo200Response]:
+        """Synchronous version of token_info_with_http_info"""
+        return async_to_sync(self._token_info_async_with_http_info)(
             x_refresh_token=x_refresh_token,
             _request_timeout=_request_timeout,
             _request_auth=_request_auth,
@@ -4085,7 +4950,7 @@ class AuthApi:
         )
 
     @validate_call
-    def _rotate_tokens_sync_without_preload_content(
+    def _token_info_sync_without_preload_content(
         self,
         x_refresh_token: Annotated[
             Optional[StrictStr],
@@ -4103,8 +4968,8 @@ class AuthApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Synchronous version of rotate_tokens_without_preload_content"""
-        return async_to_sync(self._rotate_tokens_async_without_preload_content)(
+        """Synchronous version of token_info_without_preload_content"""
+        return async_to_sync(self._token_info_async_without_preload_content)(
             x_refresh_token=x_refresh_token,
             _request_timeout=_request_timeout,
             _request_auth=_request_auth,
@@ -4113,7 +4978,7 @@ class AuthApi:
             _host_index=_host_index,
         )
 
-    def _rotate_tokens_serialize(
+    def _token_info_serialize(
         self,
         x_refresh_token,
         _request_auth,
@@ -4150,11 +5015,11 @@ class AuthApi:
             )
 
         # authentication setting
-        _auth_settings: List[str] = []
+        _auth_settings: List[str] = ["HTTPBearer"]
 
         return self.api_client.param_serialize(
-            method="POST",
-            resource_path="/rotate-tokens",
+            method="GET",
+            resource_path="/token-info",
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -4168,12 +5033,8 @@ class AuthApi:
         )
 
     @validate_call
-    def token_info(
+    def verify(
         self,
-        x_refresh_token: Annotated[
-            Optional[StrictStr],
-            Field(description="The refresh token for rotating the access token."),
-        ] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4185,11 +5046,10 @@ class AuthApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> TokenInfo200Response:
-        """Token info"""
+    ) -> Verify200Response:
+        """Verify Bearer Token"""
         if self.is_sync:
-            return self._token_info_sync(
-                x_refresh_token=x_refresh_token,
+            return self._verify_sync(
                 _request_timeout=_request_timeout,
                 _request_auth=_request_auth,
                 _content_type=_content_type,
@@ -4198,8 +5058,7 @@ class AuthApi:
             )
 
         else:
-            return self._token_info_async(
-                x_refresh_token=x_refresh_token,
+            return self._verify_async(
                 _request_timeout=_request_timeout,
                 _request_auth=_request_auth,
                 _content_type=_content_type,
@@ -4208,12 +5067,8 @@ class AuthApi:
             )
 
     @validate_call
-    def token_info_with_http_info(
+    def verify_with_http_info(
         self,
-        x_refresh_token: Annotated[
-            Optional[StrictStr],
-            Field(description="The refresh token for rotating the access token."),
-        ] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4225,11 +5080,10 @@ class AuthApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[TokenInfo200Response]:
-        """Token info with HTTP info"""
+    ) -> ApiResponse[Verify200Response]:
+        """Verify Bearer Token with HTTP info"""
         if self.is_sync:
-            return self._token_info_sync_with_http_info(
-                x_refresh_token=x_refresh_token,
+            return self._verify_sync_with_http_info(
                 _request_timeout=_request_timeout,
                 _request_auth=_request_auth,
                 _content_type=_content_type,
@@ -4238,8 +5092,7 @@ class AuthApi:
             )
 
         else:
-            return self._token_info_async_with_http_info(
-                x_refresh_token=x_refresh_token,
+            return self._verify_async_with_http_info(
                 _request_timeout=_request_timeout,
                 _request_auth=_request_auth,
                 _content_type=_content_type,
@@ -4248,12 +5101,8 @@ class AuthApi:
             )
 
     @validate_call
-    def token_info_without_preload_content(
+    def verify_without_preload_content(
         self,
-        x_refresh_token: Annotated[
-            Optional[StrictStr],
-            Field(description="The refresh token for rotating the access token."),
-        ] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4266,10 +5115,9 @@ class AuthApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Token info without preloading content"""
+        """Verify Bearer Token without preloading content"""
         if self.is_sync:
-            return self._token_info_sync_without_preload_content(
-                x_refresh_token=x_refresh_token,
+            return self._verify_sync_without_preload_content(
                 _request_timeout=_request_timeout,
                 _request_auth=_request_auth,
                 _content_type=_content_type,
@@ -4278,8 +5126,7 @@ class AuthApi:
             )
 
         else:
-            return self._token_info_async_without_preload_content(
-                x_refresh_token=x_refresh_token,
+            return self._verify_async_without_preload_content(
                 _request_timeout=_request_timeout,
                 _request_auth=_request_auth,
                 _content_type=_content_type,
@@ -4289,12 +5136,8 @@ class AuthApi:
 
     # Private async implementation methods
     @validate_call
-    async def _token_info_async(
+    async def _verify_async(
         self,
-        x_refresh_token: Annotated[
-            Optional[StrictStr],
-            Field(description="The refresh token for rotating the access token."),
-        ] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4306,13 +5149,11 @@ class AuthApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> TokenInfo200Response:
-        """Token info
+    ) -> Verify200Response:
+        """Verify Bearer Token
 
-        Returns the payload of the access token.
+        Verifies the bearer token is valid.
 
-        :param x_refresh_token: The refresh token for rotating the access token.
-        :type x_refresh_token: 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
@@ -4335,8 +5176,7 @@ class AuthApi:
         :return: Returns the result object.
         """  # noqa: E501
 
-        _param = self._token_info_serialize(
-            x_refresh_token=x_refresh_token,
+        _param = self._verify_serialize(
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -4344,7 +5184,7 @@ class AuthApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            "200": "TokenInfo200Response",
+            "200": "Verify200Response",
         }
         response_data = await self.api_client.call_api(
             *_param, _request_timeout=_request_timeout
@@ -4356,12 +5196,8 @@ class AuthApi:
         ).data
 
     @validate_call
-    async def _token_info_async_with_http_info(
+    async def _verify_async_with_http_info(
         self,
-        x_refresh_token: Annotated[
-            Optional[StrictStr],
-            Field(description="The refresh token for rotating the access token."),
-        ] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4373,13 +5209,11 @@ class AuthApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[TokenInfo200Response]:
-        """Token info
+    ) -> ApiResponse[Verify200Response]:
+        """Verify Bearer Token
 
-        Returns the payload of the access token.
+        Verifies the bearer token is valid.
 
-        :param x_refresh_token: The refresh token for rotating the access token.
-        :type x_refresh_token: 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
@@ -4402,8 +5236,7 @@ class AuthApi:
         :return: Returns the result object.
         """  # noqa: E501
 
-        _param = self._token_info_serialize(
-            x_refresh_token=x_refresh_token,
+        _param = self._verify_serialize(
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -4411,7 +5244,7 @@ class AuthApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            "200": "TokenInfo200Response",
+            "200": "Verify200Response",
         }
         response_data = await self.api_client.call_api(
             *_param, _request_timeout=_request_timeout
@@ -4422,12 +5255,8 @@ class AuthApi:
         )
 
     @validate_call
-    async def _token_info_async_without_preload_content(
+    async def _verify_async_without_preload_content(
         self,
-        x_refresh_token: Annotated[
-            Optional[StrictStr],
-            Field(description="The refresh token for rotating the access token."),
-        ] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4440,12 +5269,10 @@ class AuthApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Token info
+        """Verify Bearer Token
 
-        Returns the payload of the access token.
+        Verifies the bearer token is valid.
 
-        :param x_refresh_token: The refresh token for rotating the access token.
-        :type x_refresh_token: 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
@@ -4468,8 +5295,7 @@ class AuthApi:
         :return: Returns the result object.
         """  # noqa: E501
 
-        _param = self._token_info_serialize(
-            x_refresh_token=x_refresh_token,
+        _param = self._verify_serialize(
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -4477,7 +5303,7 @@ class AuthApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            "200": "TokenInfo200Response",
+            "200": "Verify200Response",
         }
         response_data = await self.api_client.call_api(
             *_param, _request_timeout=_request_timeout
@@ -4486,12 +5312,8 @@ class AuthApi:
 
     # Private sync implementation methods
     @validate_call
-    def _token_info_sync(
+    def _verify_sync(
         self,
-        x_refresh_token: Annotated[
-            Optional[StrictStr],
-            Field(description="The refresh token for rotating the access token."),
-        ] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4503,10 +5325,9 @@ class AuthApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> TokenInfo200Response:
-        """Synchronous version of token_info"""
-        return async_to_sync(self._token_info_async)(
-            x_refresh_token=x_refresh_token,
+    ) -> Verify200Response:
+        """Synchronous version of verify"""
+        return async_to_sync(self._verify_async)(
             _request_timeout=_request_timeout,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -4515,12 +5336,8 @@ class AuthApi:
         )
 
     @validate_call
-    def _token_info_sync_with_http_info(
+    def _verify_sync_with_http_info(
         self,
-        x_refresh_token: Annotated[
-            Optional[StrictStr],
-            Field(description="The refresh token for rotating the access token."),
-        ] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4532,10 +5349,9 @@ class AuthApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[TokenInfo200Response]:
-        """Synchronous version of token_info_with_http_info"""
-        return async_to_sync(self._token_info_async_with_http_info)(
-            x_refresh_token=x_refresh_token,
+    ) -> ApiResponse[Verify200Response]:
+        """Synchronous version of verify_with_http_info"""
+        return async_to_sync(self._verify_async_with_http_info)(
             _request_timeout=_request_timeout,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -4544,12 +5360,8 @@ class AuthApi:
         )
 
     @validate_call
-    def _token_info_sync_without_preload_content(
+    def _verify_sync_without_preload_content(
         self,
-        x_refresh_token: Annotated[
-            Optional[StrictStr],
-            Field(description="The refresh token for rotating the access token."),
-        ] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4562,9 +5374,8 @@ class AuthApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Synchronous version of token_info_without_preload_content"""
-        return async_to_sync(self._token_info_async_without_preload_content)(
-            x_refresh_token=x_refresh_token,
+        """Synchronous version of verify_without_preload_content"""
+        return async_to_sync(self._verify_async_without_preload_content)(
             _request_timeout=_request_timeout,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -4572,9 +5383,8 @@ class AuthApi:
             _host_index=_host_index,
         )
 
-    def _token_info_serialize(
+    def _verify_serialize(
         self,
-        x_refresh_token,
         _request_auth,
         _content_type,
         _headers,
@@ -4597,8 +5407,6 @@ class AuthApi:
         # process the path parameters
         # process the query parameters
         # process the header parameters
-        if x_refresh_token is not None:
-            _header_params["X-Refresh-Token"] = x_refresh_token
         # process the form parameters
         # process the body parameter
 
@@ -4613,7 +5421,7 @@ class AuthApi:
 
         return self.api_client.param_serialize(
             method="GET",
-            resource_path="/token-info",
+            resource_path="/verify",
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -4627,8 +5435,9 @@ class AuthApi:
         )
 
     @validate_call
-    def verify(
+    def verify_api_key(
         self,
+        api_key: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4641,9 +5450,10 @@ class AuthApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> Verify200Response:
-        """Verify Bearer Token"""
+        """Verify API Key"""
         if self.is_sync:
-            return self._verify_sync(
+            return self._verify_api_key_sync(
+                api_key=api_key,
                 _request_timeout=_request_timeout,
                 _request_auth=_request_auth,
                 _content_type=_content_type,
@@ -4652,7 +5462,8 @@ class AuthApi:
             )
 
         else:
-            return self._verify_async(
+            return self._verify_api_key_async(
+                api_key=api_key,
                 _request_timeout=_request_timeout,
                 _request_auth=_request_auth,
                 _content_type=_content_type,
@@ -4661,8 +5472,9 @@ class AuthApi:
             )
 
     @validate_call
-    def verify_with_http_info(
+    def verify_api_key_with_http_info(
         self,
+        api_key: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4675,9 +5487,10 @@ class AuthApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> ApiResponse[Verify200Response]:
-        """Verify Bearer Token with HTTP info"""
+        """Verify API Key with HTTP info"""
         if self.is_sync:
-            return self._verify_sync_with_http_info(
+            return self._verify_api_key_sync_with_http_info(
+                api_key=api_key,
                 _request_timeout=_request_timeout,
                 _request_auth=_request_auth,
                 _content_type=_content_type,
@@ -4686,7 +5499,8 @@ class AuthApi:
             )
 
         else:
-            return self._verify_async_with_http_info(
+            return self._verify_api_key_async_with_http_info(
+                api_key=api_key,
                 _request_timeout=_request_timeout,
                 _request_auth=_request_auth,
                 _content_type=_content_type,
@@ -4695,8 +5509,9 @@ class AuthApi:
             )
 
     @validate_call
-    def verify_without_preload_content(
+    def verify_api_key_without_preload_content(
         self,
+        api_key: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4709,9 +5524,10 @@ class AuthApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Verify Bearer Token without preloading content"""
+        """Verify API Key without preloading content"""
         if self.is_sync:
-            return self._verify_sync_without_preload_content(
+            return self._verify_api_key_sync_without_preload_content(
+                api_key=api_key,
                 _request_timeout=_request_timeout,
                 _request_auth=_request_auth,
                 _content_type=_content_type,
@@ -4720,7 +5536,8 @@ class AuthApi:
             )
 
         else:
-            return self._verify_async_without_preload_content(
+            return self._verify_api_key_async_without_preload_content(
+                api_key=api_key,
                 _request_timeout=_request_timeout,
                 _request_auth=_request_auth,
                 _content_type=_content_type,
@@ -4730,8 +5547,9 @@ class AuthApi:
 
     # Private async implementation methods
     @validate_call
-    async def _verify_async(
+    async def _verify_api_key_async(
         self,
+        api_key: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4744,10 +5562,12 @@ class AuthApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> Verify200Response:
-        """Verify Bearer Token
+        """Verify API Key
 
-        Verifies the bearer token is valid.
+        Verifies the API key is valid.
 
+        :param api_key: (required)
+        :type api_key: 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
@@ -4770,7 +5590,8 @@ class AuthApi:
         :return: Returns the result object.
         """  # noqa: E501
 
-        _param = self._verify_serialize(
+        _param = self._verify_api_key_serialize(
+            api_key=api_key,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -4790,8 +5611,9 @@ class AuthApi:
         ).data
 
     @validate_call
-    async def _verify_async_with_http_info(
+    async def _verify_api_key_async_with_http_info(
         self,
+        api_key: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4804,10 +5626,12 @@ class AuthApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> ApiResponse[Verify200Response]:
-        """Verify Bearer Token
+        """Verify API Key
 
-        Verifies the bearer token is valid.
+        Verifies the API key is valid.
 
+        :param api_key: (required)
+        :type api_key: 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
@@ -4830,7 +5654,8 @@ class AuthApi:
         :return: Returns the result object.
         """  # noqa: E501
 
-        _param = self._verify_serialize(
+        _param = self._verify_api_key_serialize(
+            api_key=api_key,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -4849,8 +5674,9 @@ class AuthApi:
         )
 
     @validate_call
-    async def _verify_async_without_preload_content(
+    async def _verify_api_key_async_without_preload_content(
         self,
+        api_key: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4863,10 +5689,12 @@ class AuthApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Verify Bearer Token
+        """Verify API Key
 
-        Verifies the bearer token is valid.
+        Verifies the API key is valid.
 
+        :param api_key: (required)
+        :type api_key: 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
@@ -4889,7 +5717,8 @@ class AuthApi:
         :return: Returns the result object.
         """  # noqa: E501
 
-        _param = self._verify_serialize(
+        _param = self._verify_api_key_serialize(
+            api_key=api_key,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -4906,8 +5735,9 @@ class AuthApi:
 
     # Private sync implementation methods
     @validate_call
-    def _verify_sync(
+    def _verify_api_key_sync(
         self,
+        api_key: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4920,8 +5750,9 @@ class AuthApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> Verify200Response:
-        """Synchronous version of verify"""
-        return async_to_sync(self._verify_async)(
+        """Synchronous version of verify_api_key"""
+        return async_to_sync(self._verify_api_key_async)(
+            api_key=api_key,
             _request_timeout=_request_timeout,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -4930,8 +5761,9 @@ class AuthApi:
         )
 
     @validate_call
-    def _verify_sync_with_http_info(
+    def _verify_api_key_sync_with_http_info(
         self,
+        api_key: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4944,8 +5776,9 @@ class AuthApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> ApiResponse[Verify200Response]:
-        """Synchronous version of verify_with_http_info"""
-        return async_to_sync(self._verify_async_with_http_info)(
+        """Synchronous version of verify_api_key_with_http_info"""
+        return async_to_sync(self._verify_api_key_async_with_http_info)(
+            api_key=api_key,
             _request_timeout=_request_timeout,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -4954,8 +5787,9 @@ class AuthApi:
         )
 
     @validate_call
-    def _verify_sync_without_preload_content(
+    def _verify_api_key_sync_without_preload_content(
         self,
+        api_key: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4968,8 +5802,9 @@ class AuthApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Synchronous version of verify_without_preload_content"""
-        return async_to_sync(self._verify_async_without_preload_content)(
+        """Synchronous version of verify_api_key_without_preload_content"""
+        return async_to_sync(self._verify_api_key_async_without_preload_content)(
+            api_key=api_key,
             _request_timeout=_request_timeout,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -4977,8 +5812,9 @@ class AuthApi:
             _host_index=_host_index,
         )
 
-    def _verify_serialize(
+    def _verify_api_key_serialize(
         self,
+        api_key,
         _request_auth,
         _content_type,
         _headers,
@@ -5000,6 +5836,10 @@ class AuthApi:
 
         # process the path parameters
         # process the query parameters
+        if api_key is not None:
+
+            _query_params.append(("apiKey", api_key))
+
         # process the header parameters
         # process the form parameters
         # process the body parameter
@@ -5011,11 +5851,11 @@ class AuthApi:
             )
 
         # authentication setting
-        _auth_settings: List[str] = ["HTTPBearer"]
+        _auth_settings: List[str] = []
 
         return self.api_client.param_serialize(
             method="GET",
-            resource_path="/verify",
+            resource_path="/verify-api-key",
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -5029,9 +5869,10 @@ class AuthApi:
         )
 
     @validate_call
-    def verify_api_key(
+    def verify_basic_auth(
         self,
-        api_key: StrictStr,
+        username: StrictStr,
+        password: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -5044,10 +5885,11 @@ class AuthApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> Verify200Response:
-        """Verify API Key"""
+        """Verify Basic Auth"""
         if self.is_sync:
-            return self._verify_api_key_sync(
-                api_key=api_key,
+            return self._verify_basic_auth_sync(
+                username=username,
+                password=password,
                 _request_timeout=_request_timeout,
                 _request_auth=_request_auth,
                 _content_type=_content_type,
@@ -5056,8 +5898,9 @@ class AuthApi:
             )
 
         else:
-            return self._verify_api_key_async(
-                api_key=api_key,
+            return self._verify_basic_auth_async(
+                username=username,
+                password=password,
                 _request_timeout=_request_timeout,
                 _request_auth=_request_auth,
                 _content_type=_content_type,
@@ -5066,9 +5909,10 @@ class AuthApi:
             )
 
     @validate_call
-    def verify_api_key_with_http_info(
+    def verify_basic_auth_with_http_info(
         self,
-        api_key: StrictStr,
+        username: StrictStr,
+        password: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -5081,10 +5925,11 @@ class AuthApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> ApiResponse[Verify200Response]:
-        """Verify API Key with HTTP info"""
+        """Verify Basic Auth with HTTP info"""
         if self.is_sync:
-            return self._verify_api_key_sync_with_http_info(
-                api_key=api_key,
+            return self._verify_basic_auth_sync_with_http_info(
+                username=username,
+                password=password,
                 _request_timeout=_request_timeout,
                 _request_auth=_request_auth,
                 _content_type=_content_type,
@@ -5093,8 +5938,9 @@ class AuthApi:
             )
 
         else:
-            return self._verify_api_key_async_with_http_info(
-                api_key=api_key,
+            return self._verify_basic_auth_async_with_http_info(
+                username=username,
+                password=password,
                 _request_timeout=_request_timeout,
                 _request_auth=_request_auth,
                 _content_type=_content_type,
@@ -5103,9 +5949,10 @@ class AuthApi:
             )
 
     @validate_call
-    def verify_api_key_without_preload_content(
+    def verify_basic_auth_without_preload_content(
         self,
-        api_key: StrictStr,
+        username: StrictStr,
+        password: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -5118,10 +5965,11 @@ class AuthApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Verify API Key without preloading content"""
+        """Verify Basic Auth without preloading content"""
         if self.is_sync:
-            return self._verify_api_key_sync_without_preload_content(
-                api_key=api_key,
+            return self._verify_basic_auth_sync_without_preload_content(
+                username=username,
+                password=password,
                 _request_timeout=_request_timeout,
                 _request_auth=_request_auth,
                 _content_type=_content_type,
@@ -5130,8 +5978,9 @@ class AuthApi:
             )
 
         else:
-            return self._verify_api_key_async_without_preload_content(
-                api_key=api_key,
+            return self._verify_basic_auth_async_without_preload_content(
+                username=username,
+                password=password,
                 _request_timeout=_request_timeout,
                 _request_auth=_request_auth,
                 _content_type=_content_type,
@@ -5141,9 +5990,10 @@ class AuthApi:
 
     # Private async implementation methods
     @validate_call
-    async def _verify_api_key_async(
+    async def _verify_basic_auth_async(
         self,
-        api_key: StrictStr,
+        username: StrictStr,
+        password: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -5156,12 +6006,14 @@ class AuthApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> Verify200Response:
-        """Verify API Key
+        """Verify Basic Auth
 
-        Verifies the API key is valid.
+        Verifies the basic authentication credentials.
 
-        :param api_key: (required)
-        :type api_key: str
+        :param username: (required)
+        :type username: str
+        :param password: (required)
+        :type password: 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
@@ -5184,8 +6036,9 @@ class AuthApi:
         :return: Returns the result object.
         """  # noqa: E501
 
-        _param = self._verify_api_key_serialize(
-            api_key=api_key,
+        _param = self._verify_basic_auth_serialize(
+            username=username,
+            password=password,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -5205,9 +6058,10 @@ class AuthApi:
         ).data
 
     @validate_call
-    async def _verify_api_key_async_with_http_info(
+    async def _verify_basic_auth_async_with_http_info(
         self,
-        api_key: StrictStr,
+        username: StrictStr,
+        password: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -5220,12 +6074,14 @@ class AuthApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> ApiResponse[Verify200Response]:
-        """Verify API Key
+        """Verify Basic Auth
 
-        Verifies the API key is valid.
+        Verifies the basic authentication credentials.
 
-        :param api_key: (required)
-        :type api_key: str
+        :param username: (required)
+        :type username: str
+        :param password: (required)
+        :type password: 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
@@ -5248,8 +6104,9 @@ class AuthApi:
         :return: Returns the result object.
         """  # noqa: E501
 
-        _param = self._verify_api_key_serialize(
-            api_key=api_key,
+        _param = self._verify_basic_auth_serialize(
+            username=username,
+            password=password,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -5268,9 +6125,10 @@ class AuthApi:
         )
 
     @validate_call
-    async def _verify_api_key_async_without_preload_content(
+    async def _verify_basic_auth_async_without_preload_content(
         self,
-        api_key: StrictStr,
+        username: StrictStr,
+        password: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -5283,12 +6141,14 @@ class AuthApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Verify API Key
+        """Verify Basic Auth
 
-        Verifies the API key is valid.
+        Verifies the basic authentication credentials.
 
-        :param api_key: (required)
-        :type api_key: str
+        :param username: (required)
+        :type username: str
+        :param password: (required)
+        :type password: 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
@@ -5311,8 +6171,9 @@ class AuthApi:
         :return: Returns the result object.
         """  # noqa: E501
 
-        _param = self._verify_api_key_serialize(
-            api_key=api_key,
+        _param = self._verify_basic_auth_serialize(
+            username=username,
+            password=password,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -5329,9 +6190,10 @@ class AuthApi:
 
     # Private sync implementation methods
     @validate_call
-    def _verify_api_key_sync(
+    def _verify_basic_auth_sync(
         self,
-        api_key: StrictStr,
+        username: StrictStr,
+        password: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -5344,9 +6206,10 @@ class AuthApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> Verify200Response:
-        """Synchronous version of verify_api_key"""
-        return async_to_sync(self._verify_api_key_async)(
-            api_key=api_key,
+        """Synchronous version of verify_basic_auth"""
+        return async_to_sync(self._verify_basic_auth_async)(
+            username=username,
+            password=password,
             _request_timeout=_request_timeout,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -5355,9 +6218,10 @@ class AuthApi:
         )
 
     @validate_call
-    def _verify_api_key_sync_with_http_info(
+    def _verify_basic_auth_sync_with_http_info(
         self,
-        api_key: StrictStr,
+        username: StrictStr,
+        password: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -5370,9 +6234,10 @@ class AuthApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> ApiResponse[Verify200Response]:
-        """Synchronous version of verify_api_key_with_http_info"""
-        return async_to_sync(self._verify_api_key_async_with_http_info)(
-            api_key=api_key,
+        """Synchronous version of verify_basic_auth_with_http_info"""
+        return async_to_sync(self._verify_basic_auth_async_with_http_info)(
+            username=username,
+            password=password,
             _request_timeout=_request_timeout,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -5381,9 +6246,10 @@ class AuthApi:
         )
 
     @validate_call
-    def _verify_api_key_sync_without_preload_content(
+    def _verify_basic_auth_sync_without_preload_content(
         self,
-        api_key: StrictStr,
+        username: StrictStr,
+        password: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -5396,9 +6262,10 @@ class AuthApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Synchronous version of verify_api_key_without_preload_content"""
-        return async_to_sync(self._verify_api_key_async_without_preload_content)(
-            api_key=api_key,
+        """Synchronous version of verify_basic_auth_without_preload_content"""
+        return async_to_sync(self._verify_basic_auth_async_without_preload_content)(
+            username=username,
+            password=password,
             _request_timeout=_request_timeout,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -5406,9 +6273,10 @@ class AuthApi:
             _host_index=_host_index,
         )
 
-    def _verify_api_key_serialize(
+    def _verify_basic_auth_serialize(
         self,
-        api_key,
+        username,
+        password,
         _request_auth,
         _content_type,
         _headers,
@@ -5430,9 +6298,13 @@ class AuthApi:
 
         # process the path parameters
         # process the query parameters
-        if api_key is not None:
+        if username is not None:
 
-            _query_params.append(("apiKey", api_key))
+            _query_params.append(("username", username))
+
+        if password is not None:
+
+            _query_params.append(("password", password))
 
         # process the header parameters
         # process the form parameters
@@ -5449,7 +6321,7 @@ class AuthApi:
 
         return self.api_client.param_serialize(
             method="GET",
-            resource_path="/verify-api-key",
+            resource_path="/verify-basic-auth",
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,