kalugin66/windmill
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

lsp

Browse Source
This commit is contained in:
Ruben Fiszel
2022-10-08 13:25:07 +02:00
parent 6ebedfc5fb
commit ac09681d49
1430 changed files with 95542 additions and 14 deletions
Download Patch File Download Diff File Expand all files Collapse all files

0
python-client/windmill-api/windmill_api/api/workspace/__init__.py Normal file
View File

90
python-client/windmill-api/windmill_api/api/workspace/create_workspace.py Normal file
View File

@@ -0,0 +1,90 @@
from typing import Any, Dict
import httpx
from ...client import Client
from ...models.create_workspace_json_body import CreateWorkspaceJsonBody
from ...types import Response
def _get_kwargs(
*,
client: Client,
json_body: CreateWorkspaceJsonBody,
) -> Dict[str, Any]:
url = "{}/workspaces/create".format(client.base_url)
headers: Dict[str, str] = client.get_headers()
cookies: Dict[str, Any] = client.get_cookies()
json_json_body = json_body.to_dict()
return {
"method": "post",
"url": url,
"headers": headers,
"cookies": cookies,
"timeout": client.get_timeout(),
"json": json_json_body,
}
def _build_response(*, response: httpx.Response) -> Response[Any]:
return Response(
status_code=response.status_code,
content=response.content,
headers=response.headers,
parsed=None,
)
def sync_detailed(
*,
client: Client,
json_body: CreateWorkspaceJsonBody,
) -> Response[Any]:
"""create workspace
Args:
json_body (CreateWorkspaceJsonBody):
Returns:
Response[Any]
"""
kwargs = _get_kwargs(
client=client,
json_body=json_body,
)
response = httpx.request(
verify=client.verify_ssl,
**kwargs,
)
return _build_response(response=response)
async def asyncio_detailed(
*,
client: Client,
json_body: CreateWorkspaceJsonBody,
) -> Response[Any]:
"""create workspace
Args:
json_body (CreateWorkspaceJsonBody):
Returns:
Response[Any]
"""
kwargs = _get_kwargs(
client=client,
json_body=json_body,
)
async with httpx.AsyncClient(verify=client.verify_ssl) as _client:
response = await _client.request(**kwargs)
return _build_response(response=response)

97
python-client/windmill-api/windmill_api/api/workspace/delete_invite.py Normal file
View File

@@ -0,0 +1,97 @@
from typing import Any, Dict
import httpx
from ...client import Client
from ...models.delete_invite_json_body import DeleteInviteJsonBody
from ...types import Response
def _get_kwargs(
workspace: str,
*,
client: Client,
json_body: DeleteInviteJsonBody,
) -> Dict[str, Any]:
url = "{}/w/{workspace}/workspaces/delete_invite".format(client.base_url, workspace=workspace)
headers: Dict[str, str] = client.get_headers()
cookies: Dict[str, Any] = client.get_cookies()
json_json_body = json_body.to_dict()
return {
"method": "post",
"url": url,
"headers": headers,
"cookies": cookies,
"timeout": client.get_timeout(),
"json": json_json_body,
}
def _build_response(*, response: httpx.Response) -> Response[Any]:
return Response(
status_code=response.status_code,
content=response.content,
headers=response.headers,
parsed=None,
)
def sync_detailed(
workspace: str,
*,
client: Client,
json_body: DeleteInviteJsonBody,
) -> Response[Any]:
"""delete user invite
Args:
workspace (str):
json_body (DeleteInviteJsonBody):
Returns:
Response[Any]
"""
kwargs = _get_kwargs(
workspace=workspace,
client=client,
json_body=json_body,
)
response = httpx.request(
verify=client.verify_ssl,
**kwargs,
)
return _build_response(response=response)
async def asyncio_detailed(
workspace: str,
*,
client: Client,
json_body: DeleteInviteJsonBody,
) -> Response[Any]:
"""delete user invite
Args:
workspace (str):
json_body (DeleteInviteJsonBody):
Returns:
Response[Any]
"""
kwargs = _get_kwargs(
workspace=workspace,
client=client,
json_body=json_body,
)
async with httpx.AsyncClient(verify=client.verify_ssl) as _client:
response = await _client.request(**kwargs)
return _build_response(response=response)

86
python-client/windmill-api/windmill_api/api/workspace/delete_workspace.py Normal file
View File

@@ -0,0 +1,86 @@
from typing import Any, Dict
import httpx
from ...client import Client
from ...types import Response
def _get_kwargs(
workspace: str,
*,
client: Client,
) -> Dict[str, Any]:
url = "{}/w/{workspace}/workspaces/delete".format(client.base_url, workspace=workspace)
headers: Dict[str, str] = client.get_headers()
cookies: Dict[str, Any] = client.get_cookies()
return {
"method": "delete",
"url": url,
"headers": headers,
"cookies": cookies,
"timeout": client.get_timeout(),
}
def _build_response(*, response: httpx.Response) -> Response[Any]:
return Response(
status_code=response.status_code,
content=response.content,
headers=response.headers,
parsed=None,
)
def sync_detailed(
workspace: str,
*,
client: Client,
) -> Response[Any]:
"""delete workspace
Args:
workspace (str):
Returns:
Response[Any]
"""
kwargs = _get_kwargs(
workspace=workspace,
client=client,
)
response = httpx.request(
verify=client.verify_ssl,
**kwargs,
)
return _build_response(response=response)
async def asyncio_detailed(
workspace: str,
*,
client: Client,
) -> Response[Any]:
"""delete workspace
Args:
workspace (str):
Returns:
Response[Any]
"""
kwargs = _get_kwargs(
workspace=workspace,
client=client,
)
async with httpx.AsyncClient(verify=client.verify_ssl) as _client:
response = await _client.request(**kwargs)
return _build_response(response=response)

97
python-client/windmill-api/windmill_api/api/workspace/edit_slack_command.py Normal file
View File

@@ -0,0 +1,97 @@
from typing import Any, Dict
import httpx
from ...client import Client
from ...models.edit_slack_command_json_body import EditSlackCommandJsonBody
from ...types import Response
def _get_kwargs(
workspace: str,
*,
client: Client,
json_body: EditSlackCommandJsonBody,
) -> Dict[str, Any]:
url = "{}/w/{workspace}/workspaces/edit_slack_command".format(client.base_url, workspace=workspace)
headers: Dict[str, str] = client.get_headers()
cookies: Dict[str, Any] = client.get_cookies()
json_json_body = json_body.to_dict()
return {
"method": "post",
"url": url,
"headers": headers,
"cookies": cookies,
"timeout": client.get_timeout(),
"json": json_json_body,
}
def _build_response(*, response: httpx.Response) -> Response[Any]:
return Response(
status_code=response.status_code,
content=response.content,
headers=response.headers,
parsed=None,
)
def sync_detailed(
workspace: str,
*,
client: Client,
json_body: EditSlackCommandJsonBody,
) -> Response[Any]:
"""edit slack command
Args:
workspace (str):
json_body (EditSlackCommandJsonBody):
Returns:
Response[Any]
"""
kwargs = _get_kwargs(
workspace=workspace,
client=client,
json_body=json_body,
)
response = httpx.request(
verify=client.verify_ssl,
**kwargs,
)
return _build_response(response=response)
async def asyncio_detailed(
workspace: str,
*,
client: Client,
json_body: EditSlackCommandJsonBody,
) -> Response[Any]:
"""edit slack command
Args:
workspace (str):
json_body (EditSlackCommandJsonBody):
Returns:
Response[Any]
"""
kwargs = _get_kwargs(
workspace=workspace,
client=client,
json_body=json_body,
)
async with httpx.AsyncClient(verify=client.verify_ssl) as _client:
response = await _client.request(**kwargs)
return _build_response(response=response)

90
python-client/windmill-api/windmill_api/api/workspace/exists_username.py Normal file
View File

@@ -0,0 +1,90 @@
from typing import Any, Dict
import httpx
from ...client import Client
from ...models.exists_username_json_body import ExistsUsernameJsonBody
from ...types import Response
def _get_kwargs(
*,
client: Client,
json_body: ExistsUsernameJsonBody,
) -> Dict[str, Any]:
url = "{}/workspaces/exists_username".format(client.base_url)
headers: Dict[str, str] = client.get_headers()
cookies: Dict[str, Any] = client.get_cookies()
json_json_body = json_body.to_dict()
return {
"method": "post",
"url": url,
"headers": headers,
"cookies": cookies,
"timeout": client.get_timeout(),
"json": json_json_body,
}
def _build_response(*, response: httpx.Response) -> Response[Any]:
return Response(
status_code=response.status_code,
content=response.content,
headers=response.headers,
parsed=None,
)
def sync_detailed(
*,
client: Client,
json_body: ExistsUsernameJsonBody,
) -> Response[Any]:
"""exists username
Args:
json_body (ExistsUsernameJsonBody):
Returns:
Response[Any]
"""
kwargs = _get_kwargs(
client=client,
json_body=json_body,
)
response = httpx.request(
verify=client.verify_ssl,
**kwargs,
)
return _build_response(response=response)
async def asyncio_detailed(
*,
client: Client,
json_body: ExistsUsernameJsonBody,
) -> Response[Any]:
"""exists username
Args:
json_body (ExistsUsernameJsonBody):
Returns:
Response[Any]
"""
kwargs = _get_kwargs(
client=client,
json_body=json_body,
)
async with httpx.AsyncClient(verify=client.verify_ssl) as _client:
response = await _client.request(**kwargs)
return _build_response(response=response)

90
python-client/windmill-api/windmill_api/api/workspace/exists_workspace.py Normal file
View File

@@ -0,0 +1,90 @@
from typing import Any, Dict
import httpx
from ...client import Client
from ...models.exists_workspace_json_body import ExistsWorkspaceJsonBody
from ...types import Response
def _get_kwargs(
*,
client: Client,
json_body: ExistsWorkspaceJsonBody,
) -> Dict[str, Any]:
url = "{}/workspaces/exists".format(client.base_url)
headers: Dict[str, str] = client.get_headers()
cookies: Dict[str, Any] = client.get_cookies()
json_json_body = json_body.to_dict()
return {
"method": "post",
"url": url,
"headers": headers,
"cookies": cookies,
"timeout": client.get_timeout(),
"json": json_json_body,
}
def _build_response(*, response: httpx.Response) -> Response[Any]:
return Response(
status_code=response.status_code,
content=response.content,
headers=response.headers,
parsed=None,
)
def sync_detailed(
*,
client: Client,
json_body: ExistsWorkspaceJsonBody,
) -> Response[Any]:
"""exists workspace
Args:
json_body (ExistsWorkspaceJsonBody):
Returns:
Response[Any]
"""
kwargs = _get_kwargs(
client=client,
json_body=json_body,
)
response = httpx.request(
verify=client.verify_ssl,
**kwargs,
)
return _build_response(response=response)
async def asyncio_detailed(
*,
client: Client,
json_body: ExistsWorkspaceJsonBody,
) -> Response[Any]:
"""exists workspace
Args:
json_body (ExistsWorkspaceJsonBody):
Returns:
Response[Any]
"""
kwargs = _get_kwargs(
client=client,
json_body=json_body,
)
async with httpx.AsyncClient(verify=client.verify_ssl) as _client:
response = await _client.request(**kwargs)
return _build_response(response=response)

137
python-client/windmill-api/windmill_api/api/workspace/get_settings.py Normal file
View File

@@ -0,0 +1,137 @@
from typing import Any, Dict, Optional
import httpx
from ...client import Client
from ...models.get_settings_response_200 import GetSettingsResponse200
from ...types import Response
def _get_kwargs(
workspace: str,
*,
client: Client,
) -> Dict[str, Any]:
url = "{}/w/{workspace}/workspaces/get_settings".format(client.base_url, workspace=workspace)
headers: Dict[str, str] = client.get_headers()
cookies: Dict[str, Any] = client.get_cookies()
return {
"method": "get",
"url": url,
"headers": headers,
"cookies": cookies,
"timeout": client.get_timeout(),
}
def _parse_response(*, response: httpx.Response) -> Optional[GetSettingsResponse200]:
if response.status_code == 200:
response_200 = GetSettingsResponse200.from_dict(response.json())
return response_200
return None
def _build_response(*, response: httpx.Response) -> Response[GetSettingsResponse200]:
return Response(
status_code=response.status_code,
content=response.content,
headers=response.headers,
parsed=_parse_response(response=response),
)
def sync_detailed(
workspace: str,
*,
client: Client,
) -> Response[GetSettingsResponse200]:
"""get settings
Args:
workspace (str):
Returns:
Response[GetSettingsResponse200]
"""
kwargs = _get_kwargs(
workspace=workspace,
client=client,
)
response = httpx.request(
verify=client.verify_ssl,
**kwargs,
)
return _build_response(response=response)
def sync(
workspace: str,
*,
client: Client,
) -> Optional[GetSettingsResponse200]:
"""get settings
Args:
workspace (str):
Returns:
Response[GetSettingsResponse200]
"""
return sync_detailed(
workspace=workspace,
client=client,
).parsed
async def asyncio_detailed(
workspace: str,
*,
client: Client,
) -> Response[GetSettingsResponse200]:
"""get settings
Args:
workspace (str):
Returns:
Response[GetSettingsResponse200]
"""
kwargs = _get_kwargs(
workspace=workspace,
client=client,
)
async with httpx.AsyncClient(verify=client.verify_ssl) as _client:
response = await _client.request(**kwargs)
return _build_response(response=response)
async def asyncio(
workspace: str,
*,
client: Client,
) -> Optional[GetSettingsResponse200]:
"""get settings
Args:
workspace (str):
Returns:
Response[GetSettingsResponse200]
"""
return (
await asyncio_detailed(
workspace=workspace,
client=client,
)
).parsed

97
python-client/windmill-api/windmill_api/api/workspace/invite_user.py Normal file
View File

@@ -0,0 +1,97 @@
from typing import Any, Dict
import httpx
from ...client import Client
from ...models.invite_user_json_body import InviteUserJsonBody
from ...types import Response
def _get_kwargs(
workspace: str,
*,
client: Client,
json_body: InviteUserJsonBody,
) -> Dict[str, Any]:
url = "{}/w/{workspace}/workspaces/invite_user".format(client.base_url, workspace=workspace)
headers: Dict[str, str] = client.get_headers()
cookies: Dict[str, Any] = client.get_cookies()
json_json_body = json_body.to_dict()
return {
"method": "post",
"url": url,
"headers": headers,
"cookies": cookies,
"timeout": client.get_timeout(),
"json": json_json_body,
}
def _build_response(*, response: httpx.Response) -> Response[Any]:
return Response(
status_code=response.status_code,
content=response.content,
headers=response.headers,
parsed=None,
)
def sync_detailed(
workspace: str,
*,
client: Client,
json_body: InviteUserJsonBody,
) -> Response[Any]:
"""invite user to workspace
Args:
workspace (str):
json_body (InviteUserJsonBody):
Returns:
Response[Any]
"""
kwargs = _get_kwargs(
workspace=workspace,
client=client,
json_body=json_body,
)
response = httpx.request(
verify=client.verify_ssl,
**kwargs,
)
return _build_response(response=response)
async def asyncio_detailed(
workspace: str,
*,
client: Client,
json_body: InviteUserJsonBody,
) -> Response[Any]:
"""invite user to workspace
Args:
workspace (str):
json_body (InviteUserJsonBody):
Returns:
Response[Any]
"""
kwargs = _get_kwargs(
workspace=workspace,
client=client,
json_body=json_body,
)
async with httpx.AsyncClient(verify=client.verify_ssl) as _client:
response = await _client.request(**kwargs)
return _build_response(response=response)

142
python-client/windmill-api/windmill_api/api/workspace/list_pending_invites.py Normal file
View File

@@ -0,0 +1,142 @@
from typing import Any, Dict, List, Optional
import httpx
from ...client import Client
from ...models.list_pending_invites_response_200_item import ListPendingInvitesResponse200Item
from ...types import Response
def _get_kwargs(
workspace: str,
*,
client: Client,
) -> Dict[str, Any]:
url = "{}/w/{workspace}/workspaces/list_pending_invites".format(client.base_url, workspace=workspace)
headers: Dict[str, str] = client.get_headers()
cookies: Dict[str, Any] = client.get_cookies()
return {
"method": "get",
"url": url,
"headers": headers,
"cookies": cookies,
"timeout": client.get_timeout(),
}
def _parse_response(*, response: httpx.Response) -> Optional[List[ListPendingInvitesResponse200Item]]:
if response.status_code == 200:
response_200 = []
_response_200 = response.json()
for response_200_item_data in _response_200:
response_200_item = ListPendingInvitesResponse200Item.from_dict(response_200_item_data)
response_200.append(response_200_item)
return response_200
return None
def _build_response(*, response: httpx.Response) -> Response[List[ListPendingInvitesResponse200Item]]:
return Response(
status_code=response.status_code,
content=response.content,
headers=response.headers,
parsed=_parse_response(response=response),
)
def sync_detailed(
workspace: str,
*,
client: Client,
) -> Response[List[ListPendingInvitesResponse200Item]]:
"""list pending invites for a workspace
Args:
workspace (str):
Returns:
Response[List[ListPendingInvitesResponse200Item]]
"""
kwargs = _get_kwargs(
workspace=workspace,
client=client,
)
response = httpx.request(
verify=client.verify_ssl,
**kwargs,
)
return _build_response(response=response)
def sync(
workspace: str,
*,
client: Client,
) -> Optional[List[ListPendingInvitesResponse200Item]]:
"""list pending invites for a workspace
Args:
workspace (str):
Returns:
Response[List[ListPendingInvitesResponse200Item]]
"""
return sync_detailed(
workspace=workspace,
client=client,
).parsed
async def asyncio_detailed(
workspace: str,
*,
client: Client,
) -> Response[List[ListPendingInvitesResponse200Item]]:
"""list pending invites for a workspace
Args:
workspace (str):
Returns:
Response[List[ListPendingInvitesResponse200Item]]
"""
kwargs = _get_kwargs(
workspace=workspace,
client=client,
)
async with httpx.AsyncClient(verify=client.verify_ssl) as _client:
response = await _client.request(**kwargs)
return _build_response(response=response)
async def asyncio(
workspace: str,
*,
client: Client,
) -> Optional[List[ListPendingInvitesResponse200Item]]:
"""list pending invites for a workspace
Args:
workspace (str):
Returns:
Response[List[ListPendingInvitesResponse200Item]]
"""
return (
await asyncio_detailed(
workspace=workspace,
client=client,
)
).parsed

116
python-client/windmill-api/windmill_api/api/workspace/list_user_workspaces.py Normal file
View File

@@ -0,0 +1,116 @@
from typing import Any, Dict, Optional
import httpx
from ...client import Client
from ...models.list_user_workspaces_response_200 import ListUserWorkspacesResponse200
from ...types import Response
def _get_kwargs(
*,
client: Client,
) -> Dict[str, Any]:
url = "{}/workspaces/users".format(client.base_url)
headers: Dict[str, str] = client.get_headers()
cookies: Dict[str, Any] = client.get_cookies()
return {
"method": "get",
"url": url,
"headers": headers,
"cookies": cookies,
"timeout": client.get_timeout(),
}
def _parse_response(*, response: httpx.Response) -> Optional[ListUserWorkspacesResponse200]:
if response.status_code == 200:
response_200 = ListUserWorkspacesResponse200.from_dict(response.json())
return response_200
return None
def _build_response(*, response: httpx.Response) -> Response[ListUserWorkspacesResponse200]:
return Response(
status_code=response.status_code,
content=response.content,
headers=response.headers,
parsed=_parse_response(response=response),
)
def sync_detailed(
*,
client: Client,
) -> Response[ListUserWorkspacesResponse200]:
"""list all workspaces visible to me with user info
Returns:
Response[ListUserWorkspacesResponse200]
"""
kwargs = _get_kwargs(
client=client,
)
response = httpx.request(
verify=client.verify_ssl,
**kwargs,
)
return _build_response(response=response)
def sync(
*,
client: Client,
) -> Optional[ListUserWorkspacesResponse200]:
"""list all workspaces visible to me with user info
Returns:
Response[ListUserWorkspacesResponse200]
"""
return sync_detailed(
client=client,
).parsed
async def asyncio_detailed(
*,
client: Client,
) -> Response[ListUserWorkspacesResponse200]:
"""list all workspaces visible to me with user info
Returns:
Response[ListUserWorkspacesResponse200]
"""
kwargs = _get_kwargs(
client=client,
)
async with httpx.AsyncClient(verify=client.verify_ssl) as _client:
response = await _client.request(**kwargs)
return _build_response(response=response)
async def asyncio(
*,
client: Client,
) -> Optional[ListUserWorkspacesResponse200]:
"""list all workspaces visible to me with user info
Returns:
Response[ListUserWorkspacesResponse200]
"""
return (
await asyncio_detailed(
client=client,
)
).parsed

121
python-client/windmill-api/windmill_api/api/workspace/list_workspaces.py Normal file
View File

@@ -0,0 +1,121 @@
from typing import Any, Dict, List, Optional
import httpx
from ...client import Client
from ...models.list_workspaces_response_200_item import ListWorkspacesResponse200Item
from ...types import Response
def _get_kwargs(
*,
client: Client,
) -> Dict[str, Any]:
url = "{}/workspaces/list".format(client.base_url)
headers: Dict[str, str] = client.get_headers()
cookies: Dict[str, Any] = client.get_cookies()
return {
"method": "get",
"url": url,
"headers": headers,
"cookies": cookies,
"timeout": client.get_timeout(),
}
def _parse_response(*, response: httpx.Response) -> Optional[List[ListWorkspacesResponse200Item]]:
if response.status_code == 200:
response_200 = []
_response_200 = response.json()
for response_200_item_data in _response_200:
response_200_item = ListWorkspacesResponse200Item.from_dict(response_200_item_data)
response_200.append(response_200_item)
return response_200
return None
def _build_response(*, response: httpx.Response) -> Response[List[ListWorkspacesResponse200Item]]:
return Response(
status_code=response.status_code,
content=response.content,
headers=response.headers,
parsed=_parse_response(response=response),
)
def sync_detailed(
*,
client: Client,
) -> Response[List[ListWorkspacesResponse200Item]]:
"""list all workspaces visible to me
Returns:
Response[List[ListWorkspacesResponse200Item]]
"""
kwargs = _get_kwargs(
client=client,
)
response = httpx.request(
verify=client.verify_ssl,
**kwargs,
)
return _build_response(response=response)
def sync(
*,
client: Client,
) -> Optional[List[ListWorkspacesResponse200Item]]:
"""list all workspaces visible to me
Returns:
Response[List[ListWorkspacesResponse200Item]]
"""
return sync_detailed(
client=client,
).parsed
async def asyncio_detailed(
*,
client: Client,
) -> Response[List[ListWorkspacesResponse200Item]]:
"""list all workspaces visible to me
Returns:
Response[List[ListWorkspacesResponse200Item]]
"""
kwargs = _get_kwargs(
client=client,
)
async with httpx.AsyncClient(verify=client.verify_ssl) as _client:
response = await _client.request(**kwargs)
return _build_response(response=response)
async def asyncio(
*,
client: Client,
) -> Optional[List[ListWorkspacesResponse200Item]]:
"""list all workspaces visible to me
Returns:
Response[List[ListWorkspacesResponse200Item]]
"""
return (
await asyncio_detailed(
client=client,
)
).parsed

163
python-client/windmill-api/windmill_api/api/workspace/list_workspaces_as_super_admin.py Normal file
View File

@@ -0,0 +1,163 @@
from typing import Any, Dict, List, Optional, Union
import httpx
from ...client import Client
from ...models.list_workspaces_as_super_admin_response_200_item import ListWorkspacesAsSuperAdminResponse200Item
from ...types import UNSET, Response, Unset
def _get_kwargs(
*,
client: Client,
page: Union[Unset, None, int] = UNSET,
per_page: Union[Unset, None, int] = UNSET,
) -> Dict[str, Any]:
url = "{}/workspaces/list_as_superadmin".format(client.base_url)
headers: Dict[str, str] = client.get_headers()
cookies: Dict[str, Any] = client.get_cookies()
params: Dict[str, Any] = {}
params["page"] = page
params["per_page"] = per_page
params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
return {
"method": "get",
"url": url,
"headers": headers,
"cookies": cookies,
"timeout": client.get_timeout(),
"params": params,
}
def _parse_response(*, response: httpx.Response) -> Optional[List[ListWorkspacesAsSuperAdminResponse200Item]]:
if response.status_code == 200:
response_200 = []
_response_200 = response.json()
for response_200_item_data in _response_200:
response_200_item = ListWorkspacesAsSuperAdminResponse200Item.from_dict(response_200_item_data)
response_200.append(response_200_item)
return response_200
return None
def _build_response(*, response: httpx.Response) -> Response[List[ListWorkspacesAsSuperAdminResponse200Item]]:
return Response(
status_code=response.status_code,
content=response.content,
headers=response.headers,
parsed=_parse_response(response=response),
)
def sync_detailed(
*,
client: Client,
page: Union[Unset, None, int] = UNSET,
per_page: Union[Unset, None, int] = UNSET,
) -> Response[List[ListWorkspacesAsSuperAdminResponse200Item]]:
"""list all workspaces as super admin (require to be super admin)
Args:
page (Union[Unset, None, int]):
per_page (Union[Unset, None, int]):
Returns:
Response[List[ListWorkspacesAsSuperAdminResponse200Item]]
"""
kwargs = _get_kwargs(
client=client,
page=page,
per_page=per_page,
)
response = httpx.request(
verify=client.verify_ssl,
**kwargs,
)
return _build_response(response=response)
def sync(
*,
client: Client,
page: Union[Unset, None, int] = UNSET,
per_page: Union[Unset, None, int] = UNSET,
) -> Optional[List[ListWorkspacesAsSuperAdminResponse200Item]]:
"""list all workspaces as super admin (require to be super admin)
Args:
page (Union[Unset, None, int]):
per_page (Union[Unset, None, int]):
Returns:
Response[List[ListWorkspacesAsSuperAdminResponse200Item]]
"""
return sync_detailed(
client=client,
page=page,
per_page=per_page,
).parsed
async def asyncio_detailed(
*,
client: Client,
page: Union[Unset, None, int] = UNSET,
per_page: Union[Unset, None, int] = UNSET,
) -> Response[List[ListWorkspacesAsSuperAdminResponse200Item]]:
"""list all workspaces as super admin (require to be super admin)
Args:
page (Union[Unset, None, int]):
per_page (Union[Unset, None, int]):
Returns:
Response[List[ListWorkspacesAsSuperAdminResponse200Item]]
"""
kwargs = _get_kwargs(
client=client,
page=page,
per_page=per_page,
)
async with httpx.AsyncClient(verify=client.verify_ssl) as _client:
response = await _client.request(**kwargs)
return _build_response(response=response)
async def asyncio(
*,
client: Client,
page: Union[Unset, None, int] = UNSET,
per_page: Union[Unset, None, int] = UNSET,
) -> Optional[List[ListWorkspacesAsSuperAdminResponse200Item]]:
"""list all workspaces as super admin (require to be super admin)
Args:
page (Union[Unset, None, int]):
per_page (Union[Unset, None, int]):
Returns:
Response[List[ListWorkspacesAsSuperAdminResponse200Item]]
"""
return (
await asyncio_detailed(
client=client,
page=page,
per_page=per_page,
)
).parsed