lsp

python-client/windmill-api/windmill_api/__init__.py

@@ -0,0 +1,2 @@
+""" A client library for accessing Windmill server API """
+from .client import AuthenticatedClient, Client

python-client/windmill-api/windmill_api/api/__init__.py

@@ -0,0 +1 @@
+""" Contains methods for accessing the API """

python-client/windmill-api/windmill_api/api/audit/get_audit_log.py

@@ -0,0 +1,150 @@
+from typing import Any, Dict, Optional
+
+import httpx
+
+from ...client import Client
+from ...models.get_audit_log_response_200 import GetAuditLogResponse200
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    id: int,
+    *,
+    client: Client,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/audit/get/{id}".format(client.base_url, workspace=workspace, id=id)
+
+    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[GetAuditLogResponse200]:
+    if response.status_code == 200:
+        response_200 = GetAuditLogResponse200.from_dict(response.json())
+
+        return response_200
+    return None
+
+
+def _build_response(*, response: httpx.Response) -> Response[GetAuditLogResponse200]:
+    return Response(
+        status_code=response.status_code,
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(response=response),
+    )
+
+
+def sync_detailed(
+    workspace: str,
+    id: int,
+    *,
+    client: Client,
+) -> Response[GetAuditLogResponse200]:
+    """get audit log (requires admin privilege)
+
+    Args:
+        workspace (str):
+        id (int):
+
+    Returns:
+        Response[GetAuditLogResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        id=id,
+        client=client,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+def sync(
+    workspace: str,
+    id: int,
+    *,
+    client: Client,
+) -> Optional[GetAuditLogResponse200]:
+    """get audit log (requires admin privilege)
+
+    Args:
+        workspace (str):
+        id (int):
+
+    Returns:
+        Response[GetAuditLogResponse200]
+    """
+
+    return sync_detailed(
+        workspace=workspace,
+        id=id,
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    workspace: str,
+    id: int,
+    *,
+    client: Client,
+) -> Response[GetAuditLogResponse200]:
+    """get audit log (requires admin privilege)
+
+    Args:
+        workspace (str):
+        id (int):
+
+    Returns:
+        Response[GetAuditLogResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        id=id,
+        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,
+    id: int,
+    *,
+    client: Client,
+) -> Optional[GetAuditLogResponse200]:
+    """get audit log (requires admin privilege)
+
+    Args:
+        workspace (str):
+        id (int):
+
+    Returns:
+        Response[GetAuditLogResponse200]
+    """
+
+    return (
+        await asyncio_detailed(
+            workspace=workspace,
+            id=id,
+            client=client,
+        )
+    ).parsed

python-client/windmill-api/windmill_api/api/audit/list_audit_logs.py

@@ -0,0 +1,280 @@
+import datetime
+from typing import Any, Dict, List, Optional, Union
+
+import httpx
+
+from ...client import Client
+from ...models.list_audit_logs_action_kind import ListAuditLogsActionKind
+from ...models.list_audit_logs_response_200_item import ListAuditLogsResponse200Item
+from ...types import UNSET, Response, Unset
+
+
+def _get_kwargs(
+    workspace: str,
+    *,
+    client: Client,
+    page: Union[Unset, None, int] = UNSET,
+    per_page: Union[Unset, None, int] = UNSET,
+    before: Union[Unset, None, datetime.datetime] = UNSET,
+    after: Union[Unset, None, datetime.datetime] = UNSET,
+    username: Union[Unset, None, str] = UNSET,
+    operation: Union[Unset, None, str] = UNSET,
+    resource: Union[Unset, None, str] = UNSET,
+    action_kind: Union[Unset, None, ListAuditLogsActionKind] = UNSET,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/audit/list".format(client.base_url, workspace=workspace)
+
+    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
+
+    json_before: Union[Unset, None, str] = UNSET
+    if not isinstance(before, Unset):
+        json_before = before.isoformat() if before else None
+
+    params["before"] = json_before
+
+    json_after: Union[Unset, None, str] = UNSET
+    if not isinstance(after, Unset):
+        json_after = after.isoformat() if after else None
+
+    params["after"] = json_after
+
+    params["username"] = username
+
+    params["operation"] = operation
+
+    params["resource"] = resource
+
+    json_action_kind: Union[Unset, None, str] = UNSET
+    if not isinstance(action_kind, Unset):
+        json_action_kind = action_kind.value if action_kind else None
+
+    params["action_kind"] = json_action_kind
+
+    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[ListAuditLogsResponse200Item]]:
+    if response.status_code == 200:
+        response_200 = []
+        _response_200 = response.json()
+        for response_200_item_data in _response_200:
+            response_200_item = ListAuditLogsResponse200Item.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[ListAuditLogsResponse200Item]]:
+    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,
+    page: Union[Unset, None, int] = UNSET,
+    per_page: Union[Unset, None, int] = UNSET,
+    before: Union[Unset, None, datetime.datetime] = UNSET,
+    after: Union[Unset, None, datetime.datetime] = UNSET,
+    username: Union[Unset, None, str] = UNSET,
+    operation: Union[Unset, None, str] = UNSET,
+    resource: Union[Unset, None, str] = UNSET,
+    action_kind: Union[Unset, None, ListAuditLogsActionKind] = UNSET,
+) -> Response[List[ListAuditLogsResponse200Item]]:
+    """list audit logs (requires admin privilege)
+
+    Args:
+        workspace (str):
+        page (Union[Unset, None, int]):
+        per_page (Union[Unset, None, int]):
+        before (Union[Unset, None, datetime.datetime]):
+        after (Union[Unset, None, datetime.datetime]):
+        username (Union[Unset, None, str]):
+        operation (Union[Unset, None, str]):
+        resource (Union[Unset, None, str]):
+        action_kind (Union[Unset, None, ListAuditLogsActionKind]):
+
+    Returns:
+        Response[List[ListAuditLogsResponse200Item]]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        client=client,
+        page=page,
+        per_page=per_page,
+        before=before,
+        after=after,
+        username=username,
+        operation=operation,
+        resource=resource,
+        action_kind=action_kind,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+def sync(
+    workspace: str,
+    *,
+    client: Client,
+    page: Union[Unset, None, int] = UNSET,
+    per_page: Union[Unset, None, int] = UNSET,
+    before: Union[Unset, None, datetime.datetime] = UNSET,
+    after: Union[Unset, None, datetime.datetime] = UNSET,
+    username: Union[Unset, None, str] = UNSET,
+    operation: Union[Unset, None, str] = UNSET,
+    resource: Union[Unset, None, str] = UNSET,
+    action_kind: Union[Unset, None, ListAuditLogsActionKind] = UNSET,
+) -> Optional[List[ListAuditLogsResponse200Item]]:
+    """list audit logs (requires admin privilege)
+
+    Args:
+        workspace (str):
+        page (Union[Unset, None, int]):
+        per_page (Union[Unset, None, int]):
+        before (Union[Unset, None, datetime.datetime]):
+        after (Union[Unset, None, datetime.datetime]):
+        username (Union[Unset, None, str]):
+        operation (Union[Unset, None, str]):
+        resource (Union[Unset, None, str]):
+        action_kind (Union[Unset, None, ListAuditLogsActionKind]):
+
+    Returns:
+        Response[List[ListAuditLogsResponse200Item]]
+    """
+
+    return sync_detailed(
+        workspace=workspace,
+        client=client,
+        page=page,
+        per_page=per_page,
+        before=before,
+        after=after,
+        username=username,
+        operation=operation,
+        resource=resource,
+        action_kind=action_kind,
+    ).parsed
+
+
+async def asyncio_detailed(
+    workspace: str,
+    *,
+    client: Client,
+    page: Union[Unset, None, int] = UNSET,
+    per_page: Union[Unset, None, int] = UNSET,
+    before: Union[Unset, None, datetime.datetime] = UNSET,
+    after: Union[Unset, None, datetime.datetime] = UNSET,
+    username: Union[Unset, None, str] = UNSET,
+    operation: Union[Unset, None, str] = UNSET,
+    resource: Union[Unset, None, str] = UNSET,
+    action_kind: Union[Unset, None, ListAuditLogsActionKind] = UNSET,
+) -> Response[List[ListAuditLogsResponse200Item]]:
+    """list audit logs (requires admin privilege)
+
+    Args:
+        workspace (str):
+        page (Union[Unset, None, int]):
+        per_page (Union[Unset, None, int]):
+        before (Union[Unset, None, datetime.datetime]):
+        after (Union[Unset, None, datetime.datetime]):
+        username (Union[Unset, None, str]):
+        operation (Union[Unset, None, str]):
+        resource (Union[Unset, None, str]):
+        action_kind (Union[Unset, None, ListAuditLogsActionKind]):
+
+    Returns:
+        Response[List[ListAuditLogsResponse200Item]]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        client=client,
+        page=page,
+        per_page=per_page,
+        before=before,
+        after=after,
+        username=username,
+        operation=operation,
+        resource=resource,
+        action_kind=action_kind,
+    )
+
+    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,
+    page: Union[Unset, None, int] = UNSET,
+    per_page: Union[Unset, None, int] = UNSET,
+    before: Union[Unset, None, datetime.datetime] = UNSET,
+    after: Union[Unset, None, datetime.datetime] = UNSET,
+    username: Union[Unset, None, str] = UNSET,
+    operation: Union[Unset, None, str] = UNSET,
+    resource: Union[Unset, None, str] = UNSET,
+    action_kind: Union[Unset, None, ListAuditLogsActionKind] = UNSET,
+) -> Optional[List[ListAuditLogsResponse200Item]]:
+    """list audit logs (requires admin privilege)
+
+    Args:
+        workspace (str):
+        page (Union[Unset, None, int]):
+        per_page (Union[Unset, None, int]):
+        before (Union[Unset, None, datetime.datetime]):
+        after (Union[Unset, None, datetime.datetime]):
+        username (Union[Unset, None, str]):
+        operation (Union[Unset, None, str]):
+        resource (Union[Unset, None, str]):
+        action_kind (Union[Unset, None, ListAuditLogsActionKind]):
+
+    Returns:
+        Response[List[ListAuditLogsResponse200Item]]
+    """
+
+    return (
+        await asyncio_detailed(
+            workspace=workspace,
+            client=client,
+            page=page,
+            per_page=per_page,
+            before=before,
+            after=after,
+            username=username,
+            operation=operation,
+            resource=resource,
+            action_kind=action_kind,
+        )
+    ).parsed

python-client/windmill-api/windmill_api/api/flow/archive_flow_by_path.py

@@ -0,0 +1,93 @@
+from typing import Any, Dict
+
+import httpx
+
+from ...client import Client
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/flows/archive/{path}".format(client.base_url, workspace=workspace, path=path)
+
+    headers: Dict[str, str] = client.get_headers()
+    cookies: Dict[str, Any] = client.get_cookies()
+
+    return {
+        "method": "post",
+        "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,
+    path: str,
+    *,
+    client: Client,
+) -> Response[Any]:
+    """archive flow by path
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        client=client,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+async def asyncio_detailed(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Response[Any]:
+    """archive flow by path
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        client=client,
+    )
+
+    async with httpx.AsyncClient(verify=client.verify_ssl) as _client:
+        response = await _client.request(**kwargs)
+
+    return _build_response(response=response)

python-client/windmill-api/windmill_api/api/flow/create_flow.py

@@ -0,0 +1,97 @@
+from typing import Any, Dict
+
+import httpx
+
+from ...client import Client
+from ...models.create_flow_json_body import CreateFlowJsonBody
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    *,
+    client: Client,
+    json_body: CreateFlowJsonBody,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/flows/create".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: CreateFlowJsonBody,
+) -> Response[Any]:
+    """create flow
+
+    Args:
+        workspace (str):
+        json_body (CreateFlowJsonBody):
+
+    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: CreateFlowJsonBody,
+) -> Response[Any]:
+    """create flow
+
+    Args:
+        workspace (str):
+        json_body (CreateFlowJsonBody):
+
+    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)

python-client/windmill-api/windmill_api/api/flow/exists_flow_by_path.py

@@ -0,0 +1,148 @@
+from typing import Any, Dict, Optional, cast
+
+import httpx
+
+from ...client import Client
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/flows/exists/{path}".format(client.base_url, workspace=workspace, path=path)
+
+    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[bool]:
+    if response.status_code == 200:
+        response_200 = cast(bool, response.json())
+        return response_200
+    return None
+
+
+def _build_response(*, response: httpx.Response) -> Response[bool]:
+    return Response(
+        status_code=response.status_code,
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(response=response),
+    )
+
+
+def sync_detailed(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Response[bool]:
+    """exists flow by path
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[bool]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        client=client,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+def sync(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Optional[bool]:
+    """exists flow by path
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[bool]
+    """
+
+    return sync_detailed(
+        workspace=workspace,
+        path=path,
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Response[bool]:
+    """exists flow by path
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[bool]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        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,
+    path: str,
+    *,
+    client: Client,
+) -> Optional[bool]:
+    """exists flow by path
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[bool]
+    """
+
+    return (
+        await asyncio_detailed(
+            workspace=workspace,
+            path=path,
+            client=client,
+        )
+    ).parsed

python-client/windmill-api/windmill_api/api/flow/get_flow_by_path.py

@@ -0,0 +1,150 @@
+from typing import Any, Dict, Optional
+
+import httpx
+
+from ...client import Client
+from ...models.get_flow_by_path_response_200 import GetFlowByPathResponse200
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/flows/get/{path}".format(client.base_url, workspace=workspace, path=path)
+
+    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[GetFlowByPathResponse200]:
+    if response.status_code == 200:
+        response_200 = GetFlowByPathResponse200.from_dict(response.json())
+
+        return response_200
+    return None
+
+
+def _build_response(*, response: httpx.Response) -> Response[GetFlowByPathResponse200]:
+    return Response(
+        status_code=response.status_code,
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(response=response),
+    )
+
+
+def sync_detailed(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Response[GetFlowByPathResponse200]:
+    """get flow by path
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[GetFlowByPathResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        client=client,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+def sync(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Optional[GetFlowByPathResponse200]:
+    """get flow by path
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[GetFlowByPathResponse200]
+    """
+
+    return sync_detailed(
+        workspace=workspace,
+        path=path,
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Response[GetFlowByPathResponse200]:
+    """get flow by path
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[GetFlowByPathResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        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,
+    path: str,
+    *,
+    client: Client,
+) -> Optional[GetFlowByPathResponse200]:
+    """get flow by path
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[GetFlowByPathResponse200]
+    """
+
+    return (
+        await asyncio_detailed(
+            workspace=workspace,
+            path=path,
+            client=client,
+        )
+    ).parsed

python-client/windmill-api/windmill_api/api/flow/get_hub_flow_by_id.py

@@ -0,0 +1,137 @@
+from typing import Any, Dict, Optional
+
+import httpx
+
+from ...client import Client
+from ...models.get_hub_flow_by_id_response_200 import GetHubFlowByIdResponse200
+from ...types import Response
+
+
+def _get_kwargs(
+    id: int,
+    *,
+    client: Client,
+) -> Dict[str, Any]:
+    url = "{}/flows/hub/get/{id}".format(client.base_url, id=id)
+
+    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[GetHubFlowByIdResponse200]:
+    if response.status_code == 200:
+        response_200 = GetHubFlowByIdResponse200.from_dict(response.json())
+
+        return response_200
+    return None
+
+
+def _build_response(*, response: httpx.Response) -> Response[GetHubFlowByIdResponse200]:
+    return Response(
+        status_code=response.status_code,
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(response=response),
+    )
+
+
+def sync_detailed(
+    id: int,
+    *,
+    client: Client,
+) -> Response[GetHubFlowByIdResponse200]:
+    """get hub flow by id
+
+    Args:
+        id (int):
+
+    Returns:
+        Response[GetHubFlowByIdResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        id=id,
+        client=client,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+def sync(
+    id: int,
+    *,
+    client: Client,
+) -> Optional[GetHubFlowByIdResponse200]:
+    """get hub flow by id
+
+    Args:
+        id (int):
+
+    Returns:
+        Response[GetHubFlowByIdResponse200]
+    """
+
+    return sync_detailed(
+        id=id,
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    id: int,
+    *,
+    client: Client,
+) -> Response[GetHubFlowByIdResponse200]:
+    """get hub flow by id
+
+    Args:
+        id (int):
+
+    Returns:
+        Response[GetHubFlowByIdResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        id=id,
+        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(
+    id: int,
+    *,
+    client: Client,
+) -> Optional[GetHubFlowByIdResponse200]:
+    """get hub flow by id
+
+    Args:
+        id (int):
+
+    Returns:
+        Response[GetHubFlowByIdResponse200]
+    """
+
+    return (
+        await asyncio_detailed(
+            id=id,
+            client=client,
+        )
+    ).parsed

python-client/windmill-api/windmill_api/api/flow/list_flows.py

@@ -0,0 +1,251 @@
+from typing import Any, Dict, List, Optional, Union
+
+import httpx
+
+from ...client import Client
+from ...models.list_flows_response_200_item import ListFlowsResponse200Item
+from ...types import UNSET, Response, Unset
+
+
+def _get_kwargs(
+    workspace: str,
+    *,
+    client: Client,
+    page: Union[Unset, None, int] = UNSET,
+    per_page: Union[Unset, None, int] = UNSET,
+    order_desc: Union[Unset, None, bool] = UNSET,
+    created_by: Union[Unset, None, str] = UNSET,
+    path_start: Union[Unset, None, str] = UNSET,
+    path_exact: Union[Unset, None, str] = UNSET,
+    show_archived: Union[Unset, None, bool] = UNSET,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/flows/list".format(client.base_url, workspace=workspace)
+
+    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["order_desc"] = order_desc
+
+    params["created_by"] = created_by
+
+    params["path_start"] = path_start
+
+    params["path_exact"] = path_exact
+
+    params["show_archived"] = show_archived
+
+    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[ListFlowsResponse200Item]]:
+    if response.status_code == 200:
+        response_200 = []
+        _response_200 = response.json()
+        for response_200_item_data in _response_200:
+            response_200_item = ListFlowsResponse200Item.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[ListFlowsResponse200Item]]:
+    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,
+    page: Union[Unset, None, int] = UNSET,
+    per_page: Union[Unset, None, int] = UNSET,
+    order_desc: Union[Unset, None, bool] = UNSET,
+    created_by: Union[Unset, None, str] = UNSET,
+    path_start: Union[Unset, None, str] = UNSET,
+    path_exact: Union[Unset, None, str] = UNSET,
+    show_archived: Union[Unset, None, bool] = UNSET,
+) -> Response[List[ListFlowsResponse200Item]]:
+    """list all available flows
+
+    Args:
+        workspace (str):
+        page (Union[Unset, None, int]):
+        per_page (Union[Unset, None, int]):
+        order_desc (Union[Unset, None, bool]):
+        created_by (Union[Unset, None, str]):
+        path_start (Union[Unset, None, str]):
+        path_exact (Union[Unset, None, str]):
+        show_archived (Union[Unset, None, bool]):
+
+    Returns:
+        Response[List[ListFlowsResponse200Item]]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        client=client,
+        page=page,
+        per_page=per_page,
+        order_desc=order_desc,
+        created_by=created_by,
+        path_start=path_start,
+        path_exact=path_exact,
+        show_archived=show_archived,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+def sync(
+    workspace: str,
+    *,
+    client: Client,
+    page: Union[Unset, None, int] = UNSET,
+    per_page: Union[Unset, None, int] = UNSET,
+    order_desc: Union[Unset, None, bool] = UNSET,
+    created_by: Union[Unset, None, str] = UNSET,
+    path_start: Union[Unset, None, str] = UNSET,
+    path_exact: Union[Unset, None, str] = UNSET,
+    show_archived: Union[Unset, None, bool] = UNSET,
+) -> Optional[List[ListFlowsResponse200Item]]:
+    """list all available flows
+
+    Args:
+        workspace (str):
+        page (Union[Unset, None, int]):
+        per_page (Union[Unset, None, int]):
+        order_desc (Union[Unset, None, bool]):
+        created_by (Union[Unset, None, str]):
+        path_start (Union[Unset, None, str]):
+        path_exact (Union[Unset, None, str]):
+        show_archived (Union[Unset, None, bool]):
+
+    Returns:
+        Response[List[ListFlowsResponse200Item]]
+    """
+
+    return sync_detailed(
+        workspace=workspace,
+        client=client,
+        page=page,
+        per_page=per_page,
+        order_desc=order_desc,
+        created_by=created_by,
+        path_start=path_start,
+        path_exact=path_exact,
+        show_archived=show_archived,
+    ).parsed
+
+
+async def asyncio_detailed(
+    workspace: str,
+    *,
+    client: Client,
+    page: Union[Unset, None, int] = UNSET,
+    per_page: Union[Unset, None, int] = UNSET,
+    order_desc: Union[Unset, None, bool] = UNSET,
+    created_by: Union[Unset, None, str] = UNSET,
+    path_start: Union[Unset, None, str] = UNSET,
+    path_exact: Union[Unset, None, str] = UNSET,
+    show_archived: Union[Unset, None, bool] = UNSET,
+) -> Response[List[ListFlowsResponse200Item]]:
+    """list all available flows
+
+    Args:
+        workspace (str):
+        page (Union[Unset, None, int]):
+        per_page (Union[Unset, None, int]):
+        order_desc (Union[Unset, None, bool]):
+        created_by (Union[Unset, None, str]):
+        path_start (Union[Unset, None, str]):
+        path_exact (Union[Unset, None, str]):
+        show_archived (Union[Unset, None, bool]):
+
+    Returns:
+        Response[List[ListFlowsResponse200Item]]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        client=client,
+        page=page,
+        per_page=per_page,
+        order_desc=order_desc,
+        created_by=created_by,
+        path_start=path_start,
+        path_exact=path_exact,
+        show_archived=show_archived,
+    )
+
+    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,
+    page: Union[Unset, None, int] = UNSET,
+    per_page: Union[Unset, None, int] = UNSET,
+    order_desc: Union[Unset, None, bool] = UNSET,
+    created_by: Union[Unset, None, str] = UNSET,
+    path_start: Union[Unset, None, str] = UNSET,
+    path_exact: Union[Unset, None, str] = UNSET,
+    show_archived: Union[Unset, None, bool] = UNSET,
+) -> Optional[List[ListFlowsResponse200Item]]:
+    """list all available flows
+
+    Args:
+        workspace (str):
+        page (Union[Unset, None, int]):
+        per_page (Union[Unset, None, int]):
+        order_desc (Union[Unset, None, bool]):
+        created_by (Union[Unset, None, str]):
+        path_start (Union[Unset, None, str]):
+        path_exact (Union[Unset, None, str]):
+        show_archived (Union[Unset, None, bool]):
+
+    Returns:
+        Response[List[ListFlowsResponse200Item]]
+    """
+
+    return (
+        await asyncio_detailed(
+            workspace=workspace,
+            client=client,
+            page=page,
+            per_page=per_page,
+            order_desc=order_desc,
+            created_by=created_by,
+            path_start=path_start,
+            path_exact=path_exact,
+            show_archived=show_archived,
+        )
+    ).parsed

python-client/windmill-api/windmill_api/api/flow/list_hub_flows.py

@@ -0,0 +1,116 @@
+from typing import Any, Dict, Optional
+
+import httpx
+
+from ...client import Client
+from ...models.list_hub_flows_response_200 import ListHubFlowsResponse200
+from ...types import Response
+
+
+def _get_kwargs(
+    *,
+    client: Client,
+) -> Dict[str, Any]:
+    url = "{}/flows/hub/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[ListHubFlowsResponse200]:
+    if response.status_code == 200:
+        response_200 = ListHubFlowsResponse200.from_dict(response.json())
+
+        return response_200
+    return None
+
+
+def _build_response(*, response: httpx.Response) -> Response[ListHubFlowsResponse200]:
+    return Response(
+        status_code=response.status_code,
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: Client,
+) -> Response[ListHubFlowsResponse200]:
+    """list all available hub flows
+
+    Returns:
+        Response[ListHubFlowsResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        client=client,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+def sync(
+    *,
+    client: Client,
+) -> Optional[ListHubFlowsResponse200]:
+    """list all available hub flows
+
+    Returns:
+        Response[ListHubFlowsResponse200]
+    """
+
+    return sync_detailed(
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: Client,
+) -> Response[ListHubFlowsResponse200]:
+    """list all available hub flows
+
+    Returns:
+        Response[ListHubFlowsResponse200]
+    """
+
+    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[ListHubFlowsResponse200]:
+    """list all available hub flows
+
+    Returns:
+        Response[ListHubFlowsResponse200]
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+        )
+    ).parsed

python-client/windmill-api/windmill_api/api/flow/update_flow.py

@@ -0,0 +1,104 @@
+from typing import Any, Dict
+
+import httpx
+
+from ...client import Client
+from ...models.update_flow_json_body import UpdateFlowJsonBody
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+    json_body: UpdateFlowJsonBody,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/flows/update/{path}".format(client.base_url, workspace=workspace, path=path)
+
+    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,
+    path: str,
+    *,
+    client: Client,
+    json_body: UpdateFlowJsonBody,
+) -> Response[Any]:
+    """update flow
+
+    Args:
+        workspace (str):
+        path (str):
+        json_body (UpdateFlowJsonBody):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        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,
+    path: str,
+    *,
+    client: Client,
+    json_body: UpdateFlowJsonBody,
+) -> Response[Any]:
+    """update flow
+
+    Args:
+        workspace (str):
+        path (str):
+        json_body (UpdateFlowJsonBody):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        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)

python-client/windmill-api/windmill_api/api/granular_acl/add_granular_acls.py

@@ -0,0 +1,112 @@
+from typing import Any, Dict
+
+import httpx
+
+from ...client import Client
+from ...models.add_granular_acls_json_body import AddGranularAclsJsonBody
+from ...models.add_granular_acls_kind import AddGranularAclsKind
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    kind: AddGranularAclsKind,
+    path: str,
+    *,
+    client: Client,
+    json_body: AddGranularAclsJsonBody,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/acls/add/{kind}/{path}".format(client.base_url, workspace=workspace, kind=kind, path=path)
+
+    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,
+    kind: AddGranularAclsKind,
+    path: str,
+    *,
+    client: Client,
+    json_body: AddGranularAclsJsonBody,
+) -> Response[Any]:
+    """add granular acls
+
+    Args:
+        workspace (str):
+        kind (AddGranularAclsKind):
+        path (str):
+        json_body (AddGranularAclsJsonBody):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        kind=kind,
+        path=path,
+        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,
+    kind: AddGranularAclsKind,
+    path: str,
+    *,
+    client: Client,
+    json_body: AddGranularAclsJsonBody,
+) -> Response[Any]:
+    """add granular acls
+
+    Args:
+        workspace (str):
+        kind (AddGranularAclsKind):
+        path (str):
+        json_body (AddGranularAclsJsonBody):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        kind=kind,
+        path=path,
+        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)

python-client/windmill-api/windmill_api/api/granular_acl/get_granular_acls.py

@@ -0,0 +1,164 @@
+from typing import Any, Dict, Optional
+
+import httpx
+
+from ...client import Client
+from ...models.get_granular_acls_kind import GetGranularAclsKind
+from ...models.get_granular_acls_response_200 import GetGranularAclsResponse200
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    kind: GetGranularAclsKind,
+    path: str,
+    *,
+    client: Client,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/acls/get/{kind}/{path}".format(client.base_url, workspace=workspace, kind=kind, path=path)
+
+    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[GetGranularAclsResponse200]:
+    if response.status_code == 200:
+        response_200 = GetGranularAclsResponse200.from_dict(response.json())
+
+        return response_200
+    return None
+
+
+def _build_response(*, response: httpx.Response) -> Response[GetGranularAclsResponse200]:
+    return Response(
+        status_code=response.status_code,
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(response=response),
+    )
+
+
+def sync_detailed(
+    workspace: str,
+    kind: GetGranularAclsKind,
+    path: str,
+    *,
+    client: Client,
+) -> Response[GetGranularAclsResponse200]:
+    """get granular acls
+
+    Args:
+        workspace (str):
+        kind (GetGranularAclsKind):
+        path (str):
+
+    Returns:
+        Response[GetGranularAclsResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        kind=kind,
+        path=path,
+        client=client,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+def sync(
+    workspace: str,
+    kind: GetGranularAclsKind,
+    path: str,
+    *,
+    client: Client,
+) -> Optional[GetGranularAclsResponse200]:
+    """get granular acls
+
+    Args:
+        workspace (str):
+        kind (GetGranularAclsKind):
+        path (str):
+
+    Returns:
+        Response[GetGranularAclsResponse200]
+    """
+
+    return sync_detailed(
+        workspace=workspace,
+        kind=kind,
+        path=path,
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    workspace: str,
+    kind: GetGranularAclsKind,
+    path: str,
+    *,
+    client: Client,
+) -> Response[GetGranularAclsResponse200]:
+    """get granular acls
+
+    Args:
+        workspace (str):
+        kind (GetGranularAclsKind):
+        path (str):
+
+    Returns:
+        Response[GetGranularAclsResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        kind=kind,
+        path=path,
+        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,
+    kind: GetGranularAclsKind,
+    path: str,
+    *,
+    client: Client,
+) -> Optional[GetGranularAclsResponse200]:
+    """get granular acls
+
+    Args:
+        workspace (str):
+        kind (GetGranularAclsKind):
+        path (str):
+
+    Returns:
+        Response[GetGranularAclsResponse200]
+    """
+
+    return (
+        await asyncio_detailed(
+            workspace=workspace,
+            kind=kind,
+            path=path,
+            client=client,
+        )
+    ).parsed

python-client/windmill-api/windmill_api/api/granular_acl/remove_granular_acls.py

@@ -0,0 +1,114 @@
+from typing import Any, Dict
+
+import httpx
+
+from ...client import Client
+from ...models.remove_granular_acls_json_body import RemoveGranularAclsJsonBody
+from ...models.remove_granular_acls_kind import RemoveGranularAclsKind
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    kind: RemoveGranularAclsKind,
+    path: str,
+    *,
+    client: Client,
+    json_body: RemoveGranularAclsJsonBody,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/acls/remove/{kind}/{path}".format(
+        client.base_url, workspace=workspace, kind=kind, path=path
+    )
+
+    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,
+    kind: RemoveGranularAclsKind,
+    path: str,
+    *,
+    client: Client,
+    json_body: RemoveGranularAclsJsonBody,
+) -> Response[Any]:
+    """remove granular acls
+
+    Args:
+        workspace (str):
+        kind (RemoveGranularAclsKind):
+        path (str):
+        json_body (RemoveGranularAclsJsonBody):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        kind=kind,
+        path=path,
+        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,
+    kind: RemoveGranularAclsKind,
+    path: str,
+    *,
+    client: Client,
+    json_body: RemoveGranularAclsJsonBody,
+) -> Response[Any]:
+    """remove granular acls
+
+    Args:
+        workspace (str):
+        kind (RemoveGranularAclsKind):
+        path (str):
+        json_body (RemoveGranularAclsJsonBody):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        kind=kind,
+        path=path,
+        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)

python-client/windmill-api/windmill_api/api/group/add_user_to_group.py

@@ -0,0 +1,104 @@
+from typing import Any, Dict
+
+import httpx
+
+from ...client import Client
+from ...models.add_user_to_group_json_body import AddUserToGroupJsonBody
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    name: str,
+    *,
+    client: Client,
+    json_body: AddUserToGroupJsonBody,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/groups/adduser/{name}".format(client.base_url, workspace=workspace, name=name)
+
+    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,
+    name: str,
+    *,
+    client: Client,
+    json_body: AddUserToGroupJsonBody,
+) -> Response[Any]:
+    """add user to group
+
+    Args:
+        workspace (str):
+        name (str):
+        json_body (AddUserToGroupJsonBody):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        name=name,
+        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,
+    name: str,
+    *,
+    client: Client,
+    json_body: AddUserToGroupJsonBody,
+) -> Response[Any]:
+    """add user to group
+
+    Args:
+        workspace (str):
+        name (str):
+        json_body (AddUserToGroupJsonBody):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        name=name,
+        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)

python-client/windmill-api/windmill_api/api/group/create_group.py

@@ -0,0 +1,97 @@
+from typing import Any, Dict
+
+import httpx
+
+from ...client import Client
+from ...models.create_group_json_body import CreateGroupJsonBody
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    *,
+    client: Client,
+    json_body: CreateGroupJsonBody,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/groups/create".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: CreateGroupJsonBody,
+) -> Response[Any]:
+    """create group
+
+    Args:
+        workspace (str):
+        json_body (CreateGroupJsonBody):
+
+    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: CreateGroupJsonBody,
+) -> Response[Any]:
+    """create group
+
+    Args:
+        workspace (str):
+        json_body (CreateGroupJsonBody):
+
+    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)

python-client/windmill-api/windmill_api/api/group/delete_group.py

@@ -0,0 +1,93 @@
+from typing import Any, Dict
+
+import httpx
+
+from ...client import Client
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    name: str,
+    *,
+    client: Client,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/groups/delete/{name}".format(client.base_url, workspace=workspace, name=name)
+
+    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,
+    name: str,
+    *,
+    client: Client,
+) -> Response[Any]:
+    """delete group
+
+    Args:
+        workspace (str):
+        name (str):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        name=name,
+        client=client,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+async def asyncio_detailed(
+    workspace: str,
+    name: str,
+    *,
+    client: Client,
+) -> Response[Any]:
+    """delete group
+
+    Args:
+        workspace (str):
+        name (str):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        name=name,
+        client=client,
+    )
+
+    async with httpx.AsyncClient(verify=client.verify_ssl) as _client:
+        response = await _client.request(**kwargs)
+
+    return _build_response(response=response)

python-client/windmill-api/windmill_api/api/group/get_group.py

@@ -0,0 +1,150 @@
+from typing import Any, Dict, Optional
+
+import httpx
+
+from ...client import Client
+from ...models.get_group_response_200 import GetGroupResponse200
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    name: str,
+    *,
+    client: Client,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/groups/get/{name}".format(client.base_url, workspace=workspace, name=name)
+
+    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[GetGroupResponse200]:
+    if response.status_code == 200:
+        response_200 = GetGroupResponse200.from_dict(response.json())
+
+        return response_200
+    return None
+
+
+def _build_response(*, response: httpx.Response) -> Response[GetGroupResponse200]:
+    return Response(
+        status_code=response.status_code,
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(response=response),
+    )
+
+
+def sync_detailed(
+    workspace: str,
+    name: str,
+    *,
+    client: Client,
+) -> Response[GetGroupResponse200]:
+    """get group
+
+    Args:
+        workspace (str):
+        name (str):
+
+    Returns:
+        Response[GetGroupResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        name=name,
+        client=client,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+def sync(
+    workspace: str,
+    name: str,
+    *,
+    client: Client,
+) -> Optional[GetGroupResponse200]:
+    """get group
+
+    Args:
+        workspace (str):
+        name (str):
+
+    Returns:
+        Response[GetGroupResponse200]
+    """
+
+    return sync_detailed(
+        workspace=workspace,
+        name=name,
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    workspace: str,
+    name: str,
+    *,
+    client: Client,
+) -> Response[GetGroupResponse200]:
+    """get group
+
+    Args:
+        workspace (str):
+        name (str):
+
+    Returns:
+        Response[GetGroupResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        name=name,
+        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,
+    name: str,
+    *,
+    client: Client,
+) -> Optional[GetGroupResponse200]:
+    """get group
+
+    Args:
+        workspace (str):
+        name (str):
+
+    Returns:
+        Response[GetGroupResponse200]
+    """
+
+    return (
+        await asyncio_detailed(
+            workspace=workspace,
+            name=name,
+            client=client,
+        )
+    ).parsed

python-client/windmill-api/windmill_api/api/group/list_group_names.py

@@ -0,0 +1,136 @@
+from typing import Any, Dict, List, Optional, cast
+
+import httpx
+
+from ...client import Client
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    *,
+    client: Client,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/groups/listnames".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[str]]:
+    if response.status_code == 200:
+        response_200 = cast(List[str], response.json())
+
+        return response_200
+    return None
+
+
+def _build_response(*, response: httpx.Response) -> Response[List[str]]:
+    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[str]]:
+    """list group names
+
+    Args:
+        workspace (str):
+
+    Returns:
+        Response[List[str]]
+    """
+
+    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[str]]:
+    """list group names
+
+    Args:
+        workspace (str):
+
+    Returns:
+        Response[List[str]]
+    """
+
+    return sync_detailed(
+        workspace=workspace,
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    workspace: str,
+    *,
+    client: Client,
+) -> Response[List[str]]:
+    """list group names
+
+    Args:
+        workspace (str):
+
+    Returns:
+        Response[List[str]]
+    """
+
+    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[str]]:
+    """list group names
+
+    Args:
+        workspace (str):
+
+    Returns:
+        Response[List[str]]
+    """
+
+    return (
+        await asyncio_detailed(
+            workspace=workspace,
+            client=client,
+        )
+    ).parsed

python-client/windmill-api/windmill_api/api/group/list_groups.py

@@ -0,0 +1,176 @@
+from typing import Any, Dict, List, Optional, Union
+
+import httpx
+
+from ...client import Client
+from ...models.list_groups_response_200_item import ListGroupsResponse200Item
+from ...types import UNSET, Response, Unset
+
+
+def _get_kwargs(
+    workspace: str,
+    *,
+    client: Client,
+    page: Union[Unset, None, int] = UNSET,
+    per_page: Union[Unset, None, int] = UNSET,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/groups/list".format(client.base_url, workspace=workspace)
+
+    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[ListGroupsResponse200Item]]:
+    if response.status_code == 200:
+        response_200 = []
+        _response_200 = response.json()
+        for response_200_item_data in _response_200:
+            response_200_item = ListGroupsResponse200Item.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[ListGroupsResponse200Item]]:
+    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,
+    page: Union[Unset, None, int] = UNSET,
+    per_page: Union[Unset, None, int] = UNSET,
+) -> Response[List[ListGroupsResponse200Item]]:
+    """list groups
+
+    Args:
+        workspace (str):
+        page (Union[Unset, None, int]):
+        per_page (Union[Unset, None, int]):
+
+    Returns:
+        Response[List[ListGroupsResponse200Item]]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        client=client,
+        page=page,
+        per_page=per_page,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+def sync(
+    workspace: str,
+    *,
+    client: Client,
+    page: Union[Unset, None, int] = UNSET,
+    per_page: Union[Unset, None, int] = UNSET,
+) -> Optional[List[ListGroupsResponse200Item]]:
+    """list groups
+
+    Args:
+        workspace (str):
+        page (Union[Unset, None, int]):
+        per_page (Union[Unset, None, int]):
+
+    Returns:
+        Response[List[ListGroupsResponse200Item]]
+    """
+
+    return sync_detailed(
+        workspace=workspace,
+        client=client,
+        page=page,
+        per_page=per_page,
+    ).parsed
+
+
+async def asyncio_detailed(
+    workspace: str,
+    *,
+    client: Client,
+    page: Union[Unset, None, int] = UNSET,
+    per_page: Union[Unset, None, int] = UNSET,
+) -> Response[List[ListGroupsResponse200Item]]:
+    """list groups
+
+    Args:
+        workspace (str):
+        page (Union[Unset, None, int]):
+        per_page (Union[Unset, None, int]):
+
+    Returns:
+        Response[List[ListGroupsResponse200Item]]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        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(
+    workspace: str,
+    *,
+    client: Client,
+    page: Union[Unset, None, int] = UNSET,
+    per_page: Union[Unset, None, int] = UNSET,
+) -> Optional[List[ListGroupsResponse200Item]]:
+    """list groups
+
+    Args:
+        workspace (str):
+        page (Union[Unset, None, int]):
+        per_page (Union[Unset, None, int]):
+
+    Returns:
+        Response[List[ListGroupsResponse200Item]]
+    """
+
+    return (
+        await asyncio_detailed(
+            workspace=workspace,
+            client=client,
+            page=page,
+            per_page=per_page,
+        )
+    ).parsed

python-client/windmill-api/windmill_api/api/group/remove_user_to_group.py

@@ -0,0 +1,104 @@
+from typing import Any, Dict
+
+import httpx
+
+from ...client import Client
+from ...models.remove_user_to_group_json_body import RemoveUserToGroupJsonBody
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    name: str,
+    *,
+    client: Client,
+    json_body: RemoveUserToGroupJsonBody,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/groups/removeuser/{name}".format(client.base_url, workspace=workspace, name=name)
+
+    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,
+    name: str,
+    *,
+    client: Client,
+    json_body: RemoveUserToGroupJsonBody,
+) -> Response[Any]:
+    """remove user to group
+
+    Args:
+        workspace (str):
+        name (str):
+        json_body (RemoveUserToGroupJsonBody):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        name=name,
+        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,
+    name: str,
+    *,
+    client: Client,
+    json_body: RemoveUserToGroupJsonBody,
+) -> Response[Any]:
+    """remove user to group
+
+    Args:
+        workspace (str):
+        name (str):
+        json_body (RemoveUserToGroupJsonBody):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        name=name,
+        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)

python-client/windmill-api/windmill_api/api/group/update_group.py

@@ -0,0 +1,104 @@
+from typing import Any, Dict
+
+import httpx
+
+from ...client import Client
+from ...models.update_group_json_body import UpdateGroupJsonBody
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    name: str,
+    *,
+    client: Client,
+    json_body: UpdateGroupJsonBody,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/groups/update/{name}".format(client.base_url, workspace=workspace, name=name)
+
+    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,
+    name: str,
+    *,
+    client: Client,
+    json_body: UpdateGroupJsonBody,
+) -> Response[Any]:
+    """update group
+
+    Args:
+        workspace (str):
+        name (str):
+        json_body (UpdateGroupJsonBody):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        name=name,
+        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,
+    name: str,
+    *,
+    client: Client,
+    json_body: UpdateGroupJsonBody,
+) -> Response[Any]:
+    """update group
+
+    Args:
+        workspace (str):
+        name (str):
+        json_body (UpdateGroupJsonBody):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        name=name,
+        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)

python-client/windmill-api/windmill_api/api/job/cancel_queued_job.py

@@ -0,0 +1,104 @@
+from typing import Any, Dict
+
+import httpx
+
+from ...client import Client
+from ...models.cancel_queued_job_json_body import CancelQueuedJobJsonBody
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    id: str,
+    *,
+    client: Client,
+    json_body: CancelQueuedJobJsonBody,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/jobs/queue/cancel/{id}".format(client.base_url, workspace=workspace, id=id)
+
+    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,
+    id: str,
+    *,
+    client: Client,
+    json_body: CancelQueuedJobJsonBody,
+) -> Response[Any]:
+    """cancel queued job
+
+    Args:
+        workspace (str):
+        id (str):
+        json_body (CancelQueuedJobJsonBody):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        id=id,
+        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,
+    id: str,
+    *,
+    client: Client,
+    json_body: CancelQueuedJobJsonBody,
+) -> Response[Any]:
+    """cancel queued job
+
+    Args:
+        workspace (str):
+        id (str):
+        json_body (CancelQueuedJobJsonBody):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        id=id,
+        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)

python-client/windmill-api/windmill_api/api/job/cancel_suspended_job.py

@@ -0,0 +1,104 @@
+from typing import Any, Dict
+
+import httpx
+
+from ...client import Client
+from ...models.cancel_suspended_job_json_body import CancelSuspendedJobJsonBody
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    id: str,
+    *,
+    client: Client,
+    json_body: CancelSuspendedJobJsonBody,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/jobs/cancel/{id}".format(client.base_url, workspace=workspace, id=id)
+
+    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,
+    id: str,
+    *,
+    client: Client,
+    json_body: CancelSuspendedJobJsonBody,
+) -> Response[Any]:
+    """cancel a job for a suspended flow
+
+    Args:
+        workspace (str):
+        id (str):
+        json_body (CancelSuspendedJobJsonBody):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        id=id,
+        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,
+    id: str,
+    *,
+    client: Client,
+    json_body: CancelSuspendedJobJsonBody,
+) -> Response[Any]:
+    """cancel a job for a suspended flow
+
+    Args:
+        workspace (str):
+        id (str):
+        json_body (CancelSuspendedJobJsonBody):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        id=id,
+        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)

python-client/windmill-api/windmill_api/api/job/delete_completed_job.py

@@ -0,0 +1,150 @@
+from typing import Any, Dict, Optional
+
+import httpx
+
+from ...client import Client
+from ...models.delete_completed_job_response_200 import DeleteCompletedJobResponse200
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    id: str,
+    *,
+    client: Client,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/jobs/completed/delete/{id}".format(client.base_url, workspace=workspace, id=id)
+
+    headers: Dict[str, str] = client.get_headers()
+    cookies: Dict[str, Any] = client.get_cookies()
+
+    return {
+        "method": "post",
+        "url": url,
+        "headers": headers,
+        "cookies": cookies,
+        "timeout": client.get_timeout(),
+    }
+
+
+def _parse_response(*, response: httpx.Response) -> Optional[DeleteCompletedJobResponse200]:
+    if response.status_code == 200:
+        response_200 = DeleteCompletedJobResponse200.from_dict(response.json())
+
+        return response_200
+    return None
+
+
+def _build_response(*, response: httpx.Response) -> Response[DeleteCompletedJobResponse200]:
+    return Response(
+        status_code=response.status_code,
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(response=response),
+    )
+
+
+def sync_detailed(
+    workspace: str,
+    id: str,
+    *,
+    client: Client,
+) -> Response[DeleteCompletedJobResponse200]:
+    """delete completed job (erase content but keep run id)
+
+    Args:
+        workspace (str):
+        id (str):
+
+    Returns:
+        Response[DeleteCompletedJobResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        id=id,
+        client=client,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+def sync(
+    workspace: str,
+    id: str,
+    *,
+    client: Client,
+) -> Optional[DeleteCompletedJobResponse200]:
+    """delete completed job (erase content but keep run id)
+
+    Args:
+        workspace (str):
+        id (str):
+
+    Returns:
+        Response[DeleteCompletedJobResponse200]
+    """
+
+    return sync_detailed(
+        workspace=workspace,
+        id=id,
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    workspace: str,
+    id: str,
+    *,
+    client: Client,
+) -> Response[DeleteCompletedJobResponse200]:
+    """delete completed job (erase content but keep run id)
+
+    Args:
+        workspace (str):
+        id (str):
+
+    Returns:
+        Response[DeleteCompletedJobResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        id=id,
+        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,
+    id: str,
+    *,
+    client: Client,
+) -> Optional[DeleteCompletedJobResponse200]:
+    """delete completed job (erase content but keep run id)
+
+    Args:
+        workspace (str):
+        id (str):
+
+    Returns:
+        Response[DeleteCompletedJobResponse200]
+    """
+
+    return (
+        await asyncio_detailed(
+            workspace=workspace,
+            id=id,
+            client=client,
+        )
+    ).parsed

python-client/windmill-api/windmill_api/api/job/get_completed_job.py

@@ -0,0 +1,150 @@
+from typing import Any, Dict, Optional
+
+import httpx
+
+from ...client import Client
+from ...models.get_completed_job_response_200 import GetCompletedJobResponse200
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    id: str,
+    *,
+    client: Client,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/jobs/completed/get/{id}".format(client.base_url, workspace=workspace, id=id)
+
+    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[GetCompletedJobResponse200]:
+    if response.status_code == 200:
+        response_200 = GetCompletedJobResponse200.from_dict(response.json())
+
+        return response_200
+    return None
+
+
+def _build_response(*, response: httpx.Response) -> Response[GetCompletedJobResponse200]:
+    return Response(
+        status_code=response.status_code,
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(response=response),
+    )
+
+
+def sync_detailed(
+    workspace: str,
+    id: str,
+    *,
+    client: Client,
+) -> Response[GetCompletedJobResponse200]:
+    """get completed job
+
+    Args:
+        workspace (str):
+        id (str):
+
+    Returns:
+        Response[GetCompletedJobResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        id=id,
+        client=client,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+def sync(
+    workspace: str,
+    id: str,
+    *,
+    client: Client,
+) -> Optional[GetCompletedJobResponse200]:
+    """get completed job
+
+    Args:
+        workspace (str):
+        id (str):
+
+    Returns:
+        Response[GetCompletedJobResponse200]
+    """
+
+    return sync_detailed(
+        workspace=workspace,
+        id=id,
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    workspace: str,
+    id: str,
+    *,
+    client: Client,
+) -> Response[GetCompletedJobResponse200]:
+    """get completed job
+
+    Args:
+        workspace (str):
+        id (str):
+
+    Returns:
+        Response[GetCompletedJobResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        id=id,
+        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,
+    id: str,
+    *,
+    client: Client,
+) -> Optional[GetCompletedJobResponse200]:
+    """get completed job
+
+    Args:
+        workspace (str):
+        id (str):
+
+    Returns:
+        Response[GetCompletedJobResponse200]
+    """
+
+    return (
+        await asyncio_detailed(
+            workspace=workspace,
+            id=id,
+            client=client,
+        )
+    ).parsed

python-client/windmill-api/windmill_api/api/job/get_job.py

@@ -0,0 +1,150 @@
+from typing import Any, Dict, Optional
+
+import httpx
+
+from ...client import Client
+from ...models.get_job_response_200 import GetJobResponse200
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    id: str,
+    *,
+    client: Client,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/jobs/get/{id}".format(client.base_url, workspace=workspace, id=id)
+
+    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[GetJobResponse200]:
+    if response.status_code == 200:
+        response_200 = GetJobResponse200.from_dict(response.json())
+
+        return response_200
+    return None
+
+
+def _build_response(*, response: httpx.Response) -> Response[GetJobResponse200]:
+    return Response(
+        status_code=response.status_code,
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(response=response),
+    )
+
+
+def sync_detailed(
+    workspace: str,
+    id: str,
+    *,
+    client: Client,
+) -> Response[GetJobResponse200]:
+    """get job
+
+    Args:
+        workspace (str):
+        id (str):
+
+    Returns:
+        Response[GetJobResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        id=id,
+        client=client,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+def sync(
+    workspace: str,
+    id: str,
+    *,
+    client: Client,
+) -> Optional[GetJobResponse200]:
+    """get job
+
+    Args:
+        workspace (str):
+        id (str):
+
+    Returns:
+        Response[GetJobResponse200]
+    """
+
+    return sync_detailed(
+        workspace=workspace,
+        id=id,
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    workspace: str,
+    id: str,
+    *,
+    client: Client,
+) -> Response[GetJobResponse200]:
+    """get job
+
+    Args:
+        workspace (str):
+        id (str):
+
+    Returns:
+        Response[GetJobResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        id=id,
+        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,
+    id: str,
+    *,
+    client: Client,
+) -> Optional[GetJobResponse200]:
+    """get job
+
+    Args:
+        workspace (str):
+        id (str):
+
+    Returns:
+        Response[GetJobResponse200]
+    """
+
+    return (
+        await asyncio_detailed(
+            workspace=workspace,
+            id=id,
+            client=client,
+        )
+    ).parsed

python-client/windmill-api/windmill_api/api/job/get_job_updates.py

@@ -0,0 +1,184 @@
+from typing import Any, Dict, Optional, Union
+
+import httpx
+
+from ...client import Client
+from ...models.get_job_updates_response_200 import GetJobUpdatesResponse200
+from ...types import UNSET, Response, Unset
+
+
+def _get_kwargs(
+    workspace: str,
+    id: str,
+    *,
+    client: Client,
+    running: Union[Unset, None, bool] = UNSET,
+    log_offset: Union[Unset, None, float] = UNSET,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/jobs/getupdate/{id}".format(client.base_url, workspace=workspace, id=id)
+
+    headers: Dict[str, str] = client.get_headers()
+    cookies: Dict[str, Any] = client.get_cookies()
+
+    params: Dict[str, Any] = {}
+    params["running"] = running
+
+    params["log_offset"] = log_offset
+
+    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[GetJobUpdatesResponse200]:
+    if response.status_code == 200:
+        response_200 = GetJobUpdatesResponse200.from_dict(response.json())
+
+        return response_200
+    return None
+
+
+def _build_response(*, response: httpx.Response) -> Response[GetJobUpdatesResponse200]:
+    return Response(
+        status_code=response.status_code,
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(response=response),
+    )
+
+
+def sync_detailed(
+    workspace: str,
+    id: str,
+    *,
+    client: Client,
+    running: Union[Unset, None, bool] = UNSET,
+    log_offset: Union[Unset, None, float] = UNSET,
+) -> Response[GetJobUpdatesResponse200]:
+    """get job updates
+
+    Args:
+        workspace (str):
+        id (str):
+        running (Union[Unset, None, bool]):
+        log_offset (Union[Unset, None, float]):
+
+    Returns:
+        Response[GetJobUpdatesResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        id=id,
+        client=client,
+        running=running,
+        log_offset=log_offset,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+def sync(
+    workspace: str,
+    id: str,
+    *,
+    client: Client,
+    running: Union[Unset, None, bool] = UNSET,
+    log_offset: Union[Unset, None, float] = UNSET,
+) -> Optional[GetJobUpdatesResponse200]:
+    """get job updates
+
+    Args:
+        workspace (str):
+        id (str):
+        running (Union[Unset, None, bool]):
+        log_offset (Union[Unset, None, float]):
+
+    Returns:
+        Response[GetJobUpdatesResponse200]
+    """
+
+    return sync_detailed(
+        workspace=workspace,
+        id=id,
+        client=client,
+        running=running,
+        log_offset=log_offset,
+    ).parsed
+
+
+async def asyncio_detailed(
+    workspace: str,
+    id: str,
+    *,
+    client: Client,
+    running: Union[Unset, None, bool] = UNSET,
+    log_offset: Union[Unset, None, float] = UNSET,
+) -> Response[GetJobUpdatesResponse200]:
+    """get job updates
+
+    Args:
+        workspace (str):
+        id (str):
+        running (Union[Unset, None, bool]):
+        log_offset (Union[Unset, None, float]):
+
+    Returns:
+        Response[GetJobUpdatesResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        id=id,
+        client=client,
+        running=running,
+        log_offset=log_offset,
+    )
+
+    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,
+    id: str,
+    *,
+    client: Client,
+    running: Union[Unset, None, bool] = UNSET,
+    log_offset: Union[Unset, None, float] = UNSET,
+) -> Optional[GetJobUpdatesResponse200]:
+    """get job updates
+
+    Args:
+        workspace (str):
+        id (str):
+        running (Union[Unset, None, bool]):
+        log_offset (Union[Unset, None, float]):
+
+    Returns:
+        Response[GetJobUpdatesResponse200]
+    """
+
+    return (
+        await asyncio_detailed(
+            workspace=workspace,
+            id=id,
+            client=client,
+            running=running,
+            log_offset=log_offset,
+        )
+    ).parsed

python-client/windmill-api/windmill_api/api/job/list_completed_jobs.py

@@ -0,0 +1,335 @@
+import datetime
+from typing import Any, Dict, List, Optional, Union
+
+import httpx
+
+from ...client import Client
+from ...models.list_completed_jobs_response_200_item import ListCompletedJobsResponse200Item
+from ...types import UNSET, Response, Unset
+
+
+def _get_kwargs(
+    workspace: str,
+    *,
+    client: Client,
+    order_desc: Union[Unset, None, bool] = UNSET,
+    created_by: Union[Unset, None, str] = UNSET,
+    parent_job: Union[Unset, None, str] = UNSET,
+    script_path_exact: Union[Unset, None, str] = UNSET,
+    script_path_start: Union[Unset, None, str] = UNSET,
+    script_hash: Union[Unset, None, str] = UNSET,
+    created_before: Union[Unset, None, datetime.datetime] = UNSET,
+    created_after: Union[Unset, None, datetime.datetime] = UNSET,
+    success: Union[Unset, None, bool] = UNSET,
+    job_kinds: Union[Unset, None, str] = UNSET,
+    is_skipped: Union[Unset, None, bool] = UNSET,
+    is_flow_step: Union[Unset, None, bool] = UNSET,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/jobs/completed/list".format(client.base_url, workspace=workspace)
+
+    headers: Dict[str, str] = client.get_headers()
+    cookies: Dict[str, Any] = client.get_cookies()
+
+    params: Dict[str, Any] = {}
+    params["order_desc"] = order_desc
+
+    params["created_by"] = created_by
+
+    params["parent_job"] = parent_job
+
+    params["script_path_exact"] = script_path_exact
+
+    params["script_path_start"] = script_path_start
+
+    params["script_hash"] = script_hash
+
+    json_created_before: Union[Unset, None, str] = UNSET
+    if not isinstance(created_before, Unset):
+        json_created_before = created_before.isoformat() if created_before else None
+
+    params["created_before"] = json_created_before
+
+    json_created_after: Union[Unset, None, str] = UNSET
+    if not isinstance(created_after, Unset):
+        json_created_after = created_after.isoformat() if created_after else None
+
+    params["created_after"] = json_created_after
+
+    params["success"] = success
+
+    params["job_kinds"] = job_kinds
+
+    params["is_skipped"] = is_skipped
+
+    params["is_flow_step"] = is_flow_step
+
+    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[ListCompletedJobsResponse200Item]]:
+    if response.status_code == 200:
+        response_200 = []
+        _response_200 = response.json()
+        for response_200_item_data in _response_200:
+            response_200_item = ListCompletedJobsResponse200Item.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[ListCompletedJobsResponse200Item]]:
+    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,
+    order_desc: Union[Unset, None, bool] = UNSET,
+    created_by: Union[Unset, None, str] = UNSET,
+    parent_job: Union[Unset, None, str] = UNSET,
+    script_path_exact: Union[Unset, None, str] = UNSET,
+    script_path_start: Union[Unset, None, str] = UNSET,
+    script_hash: Union[Unset, None, str] = UNSET,
+    created_before: Union[Unset, None, datetime.datetime] = UNSET,
+    created_after: Union[Unset, None, datetime.datetime] = UNSET,
+    success: Union[Unset, None, bool] = UNSET,
+    job_kinds: Union[Unset, None, str] = UNSET,
+    is_skipped: Union[Unset, None, bool] = UNSET,
+    is_flow_step: Union[Unset, None, bool] = UNSET,
+) -> Response[List[ListCompletedJobsResponse200Item]]:
+    """list all available completed jobs
+
+    Args:
+        workspace (str):
+        order_desc (Union[Unset, None, bool]):
+        created_by (Union[Unset, None, str]):
+        parent_job (Union[Unset, None, str]):
+        script_path_exact (Union[Unset, None, str]):
+        script_path_start (Union[Unset, None, str]):
+        script_hash (Union[Unset, None, str]):
+        created_before (Union[Unset, None, datetime.datetime]):
+        created_after (Union[Unset, None, datetime.datetime]):
+        success (Union[Unset, None, bool]):
+        job_kinds (Union[Unset, None, str]):
+        is_skipped (Union[Unset, None, bool]):
+        is_flow_step (Union[Unset, None, bool]):
+
+    Returns:
+        Response[List[ListCompletedJobsResponse200Item]]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        client=client,
+        order_desc=order_desc,
+        created_by=created_by,
+        parent_job=parent_job,
+        script_path_exact=script_path_exact,
+        script_path_start=script_path_start,
+        script_hash=script_hash,
+        created_before=created_before,
+        created_after=created_after,
+        success=success,
+        job_kinds=job_kinds,
+        is_skipped=is_skipped,
+        is_flow_step=is_flow_step,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+def sync(
+    workspace: str,
+    *,
+    client: Client,
+    order_desc: Union[Unset, None, bool] = UNSET,
+    created_by: Union[Unset, None, str] = UNSET,
+    parent_job: Union[Unset, None, str] = UNSET,
+    script_path_exact: Union[Unset, None, str] = UNSET,
+    script_path_start: Union[Unset, None, str] = UNSET,
+    script_hash: Union[Unset, None, str] = UNSET,
+    created_before: Union[Unset, None, datetime.datetime] = UNSET,
+    created_after: Union[Unset, None, datetime.datetime] = UNSET,
+    success: Union[Unset, None, bool] = UNSET,
+    job_kinds: Union[Unset, None, str] = UNSET,
+    is_skipped: Union[Unset, None, bool] = UNSET,
+    is_flow_step: Union[Unset, None, bool] = UNSET,
+) -> Optional[List[ListCompletedJobsResponse200Item]]:
+    """list all available completed jobs
+
+    Args:
+        workspace (str):
+        order_desc (Union[Unset, None, bool]):
+        created_by (Union[Unset, None, str]):
+        parent_job (Union[Unset, None, str]):
+        script_path_exact (Union[Unset, None, str]):
+        script_path_start (Union[Unset, None, str]):
+        script_hash (Union[Unset, None, str]):
+        created_before (Union[Unset, None, datetime.datetime]):
+        created_after (Union[Unset, None, datetime.datetime]):
+        success (Union[Unset, None, bool]):
+        job_kinds (Union[Unset, None, str]):
+        is_skipped (Union[Unset, None, bool]):
+        is_flow_step (Union[Unset, None, bool]):
+
+    Returns:
+        Response[List[ListCompletedJobsResponse200Item]]
+    """
+
+    return sync_detailed(
+        workspace=workspace,
+        client=client,
+        order_desc=order_desc,
+        created_by=created_by,
+        parent_job=parent_job,
+        script_path_exact=script_path_exact,
+        script_path_start=script_path_start,
+        script_hash=script_hash,
+        created_before=created_before,
+        created_after=created_after,
+        success=success,
+        job_kinds=job_kinds,
+        is_skipped=is_skipped,
+        is_flow_step=is_flow_step,
+    ).parsed
+
+
+async def asyncio_detailed(
+    workspace: str,
+    *,
+    client: Client,
+    order_desc: Union[Unset, None, bool] = UNSET,
+    created_by: Union[Unset, None, str] = UNSET,
+    parent_job: Union[Unset, None, str] = UNSET,
+    script_path_exact: Union[Unset, None, str] = UNSET,
+    script_path_start: Union[Unset, None, str] = UNSET,
+    script_hash: Union[Unset, None, str] = UNSET,
+    created_before: Union[Unset, None, datetime.datetime] = UNSET,
+    created_after: Union[Unset, None, datetime.datetime] = UNSET,
+    success: Union[Unset, None, bool] = UNSET,
+    job_kinds: Union[Unset, None, str] = UNSET,
+    is_skipped: Union[Unset, None, bool] = UNSET,
+    is_flow_step: Union[Unset, None, bool] = UNSET,
+) -> Response[List[ListCompletedJobsResponse200Item]]:
+    """list all available completed jobs
+
+    Args:
+        workspace (str):
+        order_desc (Union[Unset, None, bool]):
+        created_by (Union[Unset, None, str]):
+        parent_job (Union[Unset, None, str]):
+        script_path_exact (Union[Unset, None, str]):
+        script_path_start (Union[Unset, None, str]):
+        script_hash (Union[Unset, None, str]):
+        created_before (Union[Unset, None, datetime.datetime]):
+        created_after (Union[Unset, None, datetime.datetime]):
+        success (Union[Unset, None, bool]):
+        job_kinds (Union[Unset, None, str]):
+        is_skipped (Union[Unset, None, bool]):
+        is_flow_step (Union[Unset, None, bool]):
+
+    Returns:
+        Response[List[ListCompletedJobsResponse200Item]]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        client=client,
+        order_desc=order_desc,
+        created_by=created_by,
+        parent_job=parent_job,
+        script_path_exact=script_path_exact,
+        script_path_start=script_path_start,
+        script_hash=script_hash,
+        created_before=created_before,
+        created_after=created_after,
+        success=success,
+        job_kinds=job_kinds,
+        is_skipped=is_skipped,
+        is_flow_step=is_flow_step,
+    )
+
+    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,
+    order_desc: Union[Unset, None, bool] = UNSET,
+    created_by: Union[Unset, None, str] = UNSET,
+    parent_job: Union[Unset, None, str] = UNSET,
+    script_path_exact: Union[Unset, None, str] = UNSET,
+    script_path_start: Union[Unset, None, str] = UNSET,
+    script_hash: Union[Unset, None, str] = UNSET,
+    created_before: Union[Unset, None, datetime.datetime] = UNSET,
+    created_after: Union[Unset, None, datetime.datetime] = UNSET,
+    success: Union[Unset, None, bool] = UNSET,
+    job_kinds: Union[Unset, None, str] = UNSET,
+    is_skipped: Union[Unset, None, bool] = UNSET,
+    is_flow_step: Union[Unset, None, bool] = UNSET,
+) -> Optional[List[ListCompletedJobsResponse200Item]]:
+    """list all available completed jobs
+
+    Args:
+        workspace (str):
+        order_desc (Union[Unset, None, bool]):
+        created_by (Union[Unset, None, str]):
+        parent_job (Union[Unset, None, str]):
+        script_path_exact (Union[Unset, None, str]):
+        script_path_start (Union[Unset, None, str]):
+        script_hash (Union[Unset, None, str]):
+        created_before (Union[Unset, None, datetime.datetime]):
+        created_after (Union[Unset, None, datetime.datetime]):
+        success (Union[Unset, None, bool]):
+        job_kinds (Union[Unset, None, str]):
+        is_skipped (Union[Unset, None, bool]):
+        is_flow_step (Union[Unset, None, bool]):
+
+    Returns:
+        Response[List[ListCompletedJobsResponse200Item]]
+    """
+
+    return (
+        await asyncio_detailed(
+            workspace=workspace,
+            client=client,
+            order_desc=order_desc,
+            created_by=created_by,
+            parent_job=parent_job,
+            script_path_exact=script_path_exact,
+            script_path_start=script_path_start,
+            script_hash=script_hash,
+            created_before=created_before,
+            created_after=created_after,
+            success=success,
+            job_kinds=job_kinds,
+            is_skipped=is_skipped,
+            is_flow_step=is_flow_step,
+        )
+    ).parsed

python-client/windmill-api/windmill_api/api/job/list_jobs.py

@@ -0,0 +1,320 @@
+import datetime
+from typing import Any, Dict, List, Optional, Union
+
+import httpx
+
+from ...client import Client
+from ...models.list_jobs_response_200_item import ListJobsResponse200Item
+from ...types import UNSET, Response, Unset
+
+
+def _get_kwargs(
+    workspace: str,
+    *,
+    client: Client,
+    created_by: Union[Unset, None, str] = UNSET,
+    parent_job: Union[Unset, None, str] = UNSET,
+    script_path_exact: Union[Unset, None, str] = UNSET,
+    script_path_start: Union[Unset, None, str] = UNSET,
+    script_hash: Union[Unset, None, str] = UNSET,
+    created_before: Union[Unset, None, datetime.datetime] = UNSET,
+    created_after: Union[Unset, None, datetime.datetime] = UNSET,
+    job_kinds: Union[Unset, None, str] = UNSET,
+    is_skipped: Union[Unset, None, bool] = UNSET,
+    is_flow_step: Union[Unset, None, bool] = UNSET,
+    success: Union[Unset, None, bool] = UNSET,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/jobs/list".format(client.base_url, workspace=workspace)
+
+    headers: Dict[str, str] = client.get_headers()
+    cookies: Dict[str, Any] = client.get_cookies()
+
+    params: Dict[str, Any] = {}
+    params["created_by"] = created_by
+
+    params["parent_job"] = parent_job
+
+    params["script_path_exact"] = script_path_exact
+
+    params["script_path_start"] = script_path_start
+
+    params["script_hash"] = script_hash
+
+    json_created_before: Union[Unset, None, str] = UNSET
+    if not isinstance(created_before, Unset):
+        json_created_before = created_before.isoformat() if created_before else None
+
+    params["created_before"] = json_created_before
+
+    json_created_after: Union[Unset, None, str] = UNSET
+    if not isinstance(created_after, Unset):
+        json_created_after = created_after.isoformat() if created_after else None
+
+    params["created_after"] = json_created_after
+
+    params["job_kinds"] = job_kinds
+
+    params["is_skipped"] = is_skipped
+
+    params["is_flow_step"] = is_flow_step
+
+    params["success"] = success
+
+    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[ListJobsResponse200Item]]:
+    if response.status_code == 200:
+        response_200 = []
+        _response_200 = response.json()
+        for response_200_item_data in _response_200:
+            response_200_item = ListJobsResponse200Item.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[ListJobsResponse200Item]]:
+    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,
+    created_by: Union[Unset, None, str] = UNSET,
+    parent_job: Union[Unset, None, str] = UNSET,
+    script_path_exact: Union[Unset, None, str] = UNSET,
+    script_path_start: Union[Unset, None, str] = UNSET,
+    script_hash: Union[Unset, None, str] = UNSET,
+    created_before: Union[Unset, None, datetime.datetime] = UNSET,
+    created_after: Union[Unset, None, datetime.datetime] = UNSET,
+    job_kinds: Union[Unset, None, str] = UNSET,
+    is_skipped: Union[Unset, None, bool] = UNSET,
+    is_flow_step: Union[Unset, None, bool] = UNSET,
+    success: Union[Unset, None, bool] = UNSET,
+) -> Response[List[ListJobsResponse200Item]]:
+    """list all available jobs
+
+    Args:
+        workspace (str):
+        created_by (Union[Unset, None, str]):
+        parent_job (Union[Unset, None, str]):
+        script_path_exact (Union[Unset, None, str]):
+        script_path_start (Union[Unset, None, str]):
+        script_hash (Union[Unset, None, str]):
+        created_before (Union[Unset, None, datetime.datetime]):
+        created_after (Union[Unset, None, datetime.datetime]):
+        job_kinds (Union[Unset, None, str]):
+        is_skipped (Union[Unset, None, bool]):
+        is_flow_step (Union[Unset, None, bool]):
+        success (Union[Unset, None, bool]):
+
+    Returns:
+        Response[List[ListJobsResponse200Item]]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        client=client,
+        created_by=created_by,
+        parent_job=parent_job,
+        script_path_exact=script_path_exact,
+        script_path_start=script_path_start,
+        script_hash=script_hash,
+        created_before=created_before,
+        created_after=created_after,
+        job_kinds=job_kinds,
+        is_skipped=is_skipped,
+        is_flow_step=is_flow_step,
+        success=success,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+def sync(
+    workspace: str,
+    *,
+    client: Client,
+    created_by: Union[Unset, None, str] = UNSET,
+    parent_job: Union[Unset, None, str] = UNSET,
+    script_path_exact: Union[Unset, None, str] = UNSET,
+    script_path_start: Union[Unset, None, str] = UNSET,
+    script_hash: Union[Unset, None, str] = UNSET,
+    created_before: Union[Unset, None, datetime.datetime] = UNSET,
+    created_after: Union[Unset, None, datetime.datetime] = UNSET,
+    job_kinds: Union[Unset, None, str] = UNSET,
+    is_skipped: Union[Unset, None, bool] = UNSET,
+    is_flow_step: Union[Unset, None, bool] = UNSET,
+    success: Union[Unset, None, bool] = UNSET,
+) -> Optional[List[ListJobsResponse200Item]]:
+    """list all available jobs
+
+    Args:
+        workspace (str):
+        created_by (Union[Unset, None, str]):
+        parent_job (Union[Unset, None, str]):
+        script_path_exact (Union[Unset, None, str]):
+        script_path_start (Union[Unset, None, str]):
+        script_hash (Union[Unset, None, str]):
+        created_before (Union[Unset, None, datetime.datetime]):
+        created_after (Union[Unset, None, datetime.datetime]):
+        job_kinds (Union[Unset, None, str]):
+        is_skipped (Union[Unset, None, bool]):
+        is_flow_step (Union[Unset, None, bool]):
+        success (Union[Unset, None, bool]):
+
+    Returns:
+        Response[List[ListJobsResponse200Item]]
+    """
+
+    return sync_detailed(
+        workspace=workspace,
+        client=client,
+        created_by=created_by,
+        parent_job=parent_job,
+        script_path_exact=script_path_exact,
+        script_path_start=script_path_start,
+        script_hash=script_hash,
+        created_before=created_before,
+        created_after=created_after,
+        job_kinds=job_kinds,
+        is_skipped=is_skipped,
+        is_flow_step=is_flow_step,
+        success=success,
+    ).parsed
+
+
+async def asyncio_detailed(
+    workspace: str,
+    *,
+    client: Client,
+    created_by: Union[Unset, None, str] = UNSET,
+    parent_job: Union[Unset, None, str] = UNSET,
+    script_path_exact: Union[Unset, None, str] = UNSET,
+    script_path_start: Union[Unset, None, str] = UNSET,
+    script_hash: Union[Unset, None, str] = UNSET,
+    created_before: Union[Unset, None, datetime.datetime] = UNSET,
+    created_after: Union[Unset, None, datetime.datetime] = UNSET,
+    job_kinds: Union[Unset, None, str] = UNSET,
+    is_skipped: Union[Unset, None, bool] = UNSET,
+    is_flow_step: Union[Unset, None, bool] = UNSET,
+    success: Union[Unset, None, bool] = UNSET,
+) -> Response[List[ListJobsResponse200Item]]:
+    """list all available jobs
+
+    Args:
+        workspace (str):
+        created_by (Union[Unset, None, str]):
+        parent_job (Union[Unset, None, str]):
+        script_path_exact (Union[Unset, None, str]):
+        script_path_start (Union[Unset, None, str]):
+        script_hash (Union[Unset, None, str]):
+        created_before (Union[Unset, None, datetime.datetime]):
+        created_after (Union[Unset, None, datetime.datetime]):
+        job_kinds (Union[Unset, None, str]):
+        is_skipped (Union[Unset, None, bool]):
+        is_flow_step (Union[Unset, None, bool]):
+        success (Union[Unset, None, bool]):
+
+    Returns:
+        Response[List[ListJobsResponse200Item]]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        client=client,
+        created_by=created_by,
+        parent_job=parent_job,
+        script_path_exact=script_path_exact,
+        script_path_start=script_path_start,
+        script_hash=script_hash,
+        created_before=created_before,
+        created_after=created_after,
+        job_kinds=job_kinds,
+        is_skipped=is_skipped,
+        is_flow_step=is_flow_step,
+        success=success,
+    )
+
+    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,
+    created_by: Union[Unset, None, str] = UNSET,
+    parent_job: Union[Unset, None, str] = UNSET,
+    script_path_exact: Union[Unset, None, str] = UNSET,
+    script_path_start: Union[Unset, None, str] = UNSET,
+    script_hash: Union[Unset, None, str] = UNSET,
+    created_before: Union[Unset, None, datetime.datetime] = UNSET,
+    created_after: Union[Unset, None, datetime.datetime] = UNSET,
+    job_kinds: Union[Unset, None, str] = UNSET,
+    is_skipped: Union[Unset, None, bool] = UNSET,
+    is_flow_step: Union[Unset, None, bool] = UNSET,
+    success: Union[Unset, None, bool] = UNSET,
+) -> Optional[List[ListJobsResponse200Item]]:
+    """list all available jobs
+
+    Args:
+        workspace (str):
+        created_by (Union[Unset, None, str]):
+        parent_job (Union[Unset, None, str]):
+        script_path_exact (Union[Unset, None, str]):
+        script_path_start (Union[Unset, None, str]):
+        script_hash (Union[Unset, None, str]):
+        created_before (Union[Unset, None, datetime.datetime]):
+        created_after (Union[Unset, None, datetime.datetime]):
+        job_kinds (Union[Unset, None, str]):
+        is_skipped (Union[Unset, None, bool]):
+        is_flow_step (Union[Unset, None, bool]):
+        success (Union[Unset, None, bool]):
+
+    Returns:
+        Response[List[ListJobsResponse200Item]]
+    """
+
+    return (
+        await asyncio_detailed(
+            workspace=workspace,
+            client=client,
+            created_by=created_by,
+            parent_job=parent_job,
+            script_path_exact=script_path_exact,
+            script_path_start=script_path_start,
+            script_hash=script_hash,
+            created_before=created_before,
+            created_after=created_after,
+            job_kinds=job_kinds,
+            is_skipped=is_skipped,
+            is_flow_step=is_flow_step,
+            success=success,
+        )
+    ).parsed

python-client/windmill-api/windmill_api/api/job/list_queue.py

@@ -0,0 +1,305 @@
+import datetime
+from typing import Any, Dict, List, Optional, Union
+
+import httpx
+
+from ...client import Client
+from ...models.list_queue_response_200_item import ListQueueResponse200Item
+from ...types import UNSET, Response, Unset
+
+
+def _get_kwargs(
+    workspace: str,
+    *,
+    client: Client,
+    order_desc: Union[Unset, None, bool] = UNSET,
+    created_by: Union[Unset, None, str] = UNSET,
+    parent_job: Union[Unset, None, str] = UNSET,
+    script_path_exact: Union[Unset, None, str] = UNSET,
+    script_path_start: Union[Unset, None, str] = UNSET,
+    script_hash: Union[Unset, None, str] = UNSET,
+    created_before: Union[Unset, None, datetime.datetime] = UNSET,
+    created_after: Union[Unset, None, datetime.datetime] = UNSET,
+    success: Union[Unset, None, bool] = UNSET,
+    job_kinds: Union[Unset, None, str] = UNSET,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/jobs/queue/list".format(client.base_url, workspace=workspace)
+
+    headers: Dict[str, str] = client.get_headers()
+    cookies: Dict[str, Any] = client.get_cookies()
+
+    params: Dict[str, Any] = {}
+    params["order_desc"] = order_desc
+
+    params["created_by"] = created_by
+
+    params["parent_job"] = parent_job
+
+    params["script_path_exact"] = script_path_exact
+
+    params["script_path_start"] = script_path_start
+
+    params["script_hash"] = script_hash
+
+    json_created_before: Union[Unset, None, str] = UNSET
+    if not isinstance(created_before, Unset):
+        json_created_before = created_before.isoformat() if created_before else None
+
+    params["created_before"] = json_created_before
+
+    json_created_after: Union[Unset, None, str] = UNSET
+    if not isinstance(created_after, Unset):
+        json_created_after = created_after.isoformat() if created_after else None
+
+    params["created_after"] = json_created_after
+
+    params["success"] = success
+
+    params["job_kinds"] = job_kinds
+
+    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[ListQueueResponse200Item]]:
+    if response.status_code == 200:
+        response_200 = []
+        _response_200 = response.json()
+        for response_200_item_data in _response_200:
+            response_200_item = ListQueueResponse200Item.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[ListQueueResponse200Item]]:
+    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,
+    order_desc: Union[Unset, None, bool] = UNSET,
+    created_by: Union[Unset, None, str] = UNSET,
+    parent_job: Union[Unset, None, str] = UNSET,
+    script_path_exact: Union[Unset, None, str] = UNSET,
+    script_path_start: Union[Unset, None, str] = UNSET,
+    script_hash: Union[Unset, None, str] = UNSET,
+    created_before: Union[Unset, None, datetime.datetime] = UNSET,
+    created_after: Union[Unset, None, datetime.datetime] = UNSET,
+    success: Union[Unset, None, bool] = UNSET,
+    job_kinds: Union[Unset, None, str] = UNSET,
+) -> Response[List[ListQueueResponse200Item]]:
+    """list all available queued jobs
+
+    Args:
+        workspace (str):
+        order_desc (Union[Unset, None, bool]):
+        created_by (Union[Unset, None, str]):
+        parent_job (Union[Unset, None, str]):
+        script_path_exact (Union[Unset, None, str]):
+        script_path_start (Union[Unset, None, str]):
+        script_hash (Union[Unset, None, str]):
+        created_before (Union[Unset, None, datetime.datetime]):
+        created_after (Union[Unset, None, datetime.datetime]):
+        success (Union[Unset, None, bool]):
+        job_kinds (Union[Unset, None, str]):
+
+    Returns:
+        Response[List[ListQueueResponse200Item]]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        client=client,
+        order_desc=order_desc,
+        created_by=created_by,
+        parent_job=parent_job,
+        script_path_exact=script_path_exact,
+        script_path_start=script_path_start,
+        script_hash=script_hash,
+        created_before=created_before,
+        created_after=created_after,
+        success=success,
+        job_kinds=job_kinds,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+def sync(
+    workspace: str,
+    *,
+    client: Client,
+    order_desc: Union[Unset, None, bool] = UNSET,
+    created_by: Union[Unset, None, str] = UNSET,
+    parent_job: Union[Unset, None, str] = UNSET,
+    script_path_exact: Union[Unset, None, str] = UNSET,
+    script_path_start: Union[Unset, None, str] = UNSET,
+    script_hash: Union[Unset, None, str] = UNSET,
+    created_before: Union[Unset, None, datetime.datetime] = UNSET,
+    created_after: Union[Unset, None, datetime.datetime] = UNSET,
+    success: Union[Unset, None, bool] = UNSET,
+    job_kinds: Union[Unset, None, str] = UNSET,
+) -> Optional[List[ListQueueResponse200Item]]:
+    """list all available queued jobs
+
+    Args:
+        workspace (str):
+        order_desc (Union[Unset, None, bool]):
+        created_by (Union[Unset, None, str]):
+        parent_job (Union[Unset, None, str]):
+        script_path_exact (Union[Unset, None, str]):
+        script_path_start (Union[Unset, None, str]):
+        script_hash (Union[Unset, None, str]):
+        created_before (Union[Unset, None, datetime.datetime]):
+        created_after (Union[Unset, None, datetime.datetime]):
+        success (Union[Unset, None, bool]):
+        job_kinds (Union[Unset, None, str]):
+
+    Returns:
+        Response[List[ListQueueResponse200Item]]
+    """
+
+    return sync_detailed(
+        workspace=workspace,
+        client=client,
+        order_desc=order_desc,
+        created_by=created_by,
+        parent_job=parent_job,
+        script_path_exact=script_path_exact,
+        script_path_start=script_path_start,
+        script_hash=script_hash,
+        created_before=created_before,
+        created_after=created_after,
+        success=success,
+        job_kinds=job_kinds,
+    ).parsed
+
+
+async def asyncio_detailed(
+    workspace: str,
+    *,
+    client: Client,
+    order_desc: Union[Unset, None, bool] = UNSET,
+    created_by: Union[Unset, None, str] = UNSET,
+    parent_job: Union[Unset, None, str] = UNSET,
+    script_path_exact: Union[Unset, None, str] = UNSET,
+    script_path_start: Union[Unset, None, str] = UNSET,
+    script_hash: Union[Unset, None, str] = UNSET,
+    created_before: Union[Unset, None, datetime.datetime] = UNSET,
+    created_after: Union[Unset, None, datetime.datetime] = UNSET,
+    success: Union[Unset, None, bool] = UNSET,
+    job_kinds: Union[Unset, None, str] = UNSET,
+) -> Response[List[ListQueueResponse200Item]]:
+    """list all available queued jobs
+
+    Args:
+        workspace (str):
+        order_desc (Union[Unset, None, bool]):
+        created_by (Union[Unset, None, str]):
+        parent_job (Union[Unset, None, str]):
+        script_path_exact (Union[Unset, None, str]):
+        script_path_start (Union[Unset, None, str]):
+        script_hash (Union[Unset, None, str]):
+        created_before (Union[Unset, None, datetime.datetime]):
+        created_after (Union[Unset, None, datetime.datetime]):
+        success (Union[Unset, None, bool]):
+        job_kinds (Union[Unset, None, str]):
+
+    Returns:
+        Response[List[ListQueueResponse200Item]]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        client=client,
+        order_desc=order_desc,
+        created_by=created_by,
+        parent_job=parent_job,
+        script_path_exact=script_path_exact,
+        script_path_start=script_path_start,
+        script_hash=script_hash,
+        created_before=created_before,
+        created_after=created_after,
+        success=success,
+        job_kinds=job_kinds,
+    )
+
+    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,
+    order_desc: Union[Unset, None, bool] = UNSET,
+    created_by: Union[Unset, None, str] = UNSET,
+    parent_job: Union[Unset, None, str] = UNSET,
+    script_path_exact: Union[Unset, None, str] = UNSET,
+    script_path_start: Union[Unset, None, str] = UNSET,
+    script_hash: Union[Unset, None, str] = UNSET,
+    created_before: Union[Unset, None, datetime.datetime] = UNSET,
+    created_after: Union[Unset, None, datetime.datetime] = UNSET,
+    success: Union[Unset, None, bool] = UNSET,
+    job_kinds: Union[Unset, None, str] = UNSET,
+) -> Optional[List[ListQueueResponse200Item]]:
+    """list all available queued jobs
+
+    Args:
+        workspace (str):
+        order_desc (Union[Unset, None, bool]):
+        created_by (Union[Unset, None, str]):
+        parent_job (Union[Unset, None, str]):
+        script_path_exact (Union[Unset, None, str]):
+        script_path_start (Union[Unset, None, str]):
+        script_hash (Union[Unset, None, str]):
+        created_before (Union[Unset, None, datetime.datetime]):
+        created_after (Union[Unset, None, datetime.datetime]):
+        success (Union[Unset, None, bool]):
+        job_kinds (Union[Unset, None, str]):
+
+    Returns:
+        Response[List[ListQueueResponse200Item]]
+    """
+
+    return (
+        await asyncio_detailed(
+            workspace=workspace,
+            client=client,
+            order_desc=order_desc,
+            created_by=created_by,
+            parent_job=parent_job,
+            script_path_exact=script_path_exact,
+            script_path_start=script_path_start,
+            script_hash=script_hash,
+            created_before=created_before,
+            created_after=created_after,
+            success=success,
+            job_kinds=job_kinds,
+        )
+    ).parsed

python-client/windmill-api/windmill_api/api/job/resume_suspended_job.py

@@ -0,0 +1,104 @@
+from typing import Any, Dict
+
+import httpx
+
+from ...client import Client
+from ...models.resume_suspended_job_json_body import ResumeSuspendedJobJsonBody
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    id: str,
+    *,
+    client: Client,
+    json_body: ResumeSuspendedJobJsonBody,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/jobs/resume/{id}".format(client.base_url, workspace=workspace, id=id)
+
+    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,
+    id: str,
+    *,
+    client: Client,
+    json_body: ResumeSuspendedJobJsonBody,
+) -> Response[Any]:
+    """resume a job for a suspended flow
+
+    Args:
+        workspace (str):
+        id (str):
+        json_body (ResumeSuspendedJobJsonBody):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        id=id,
+        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,
+    id: str,
+    *,
+    client: Client,
+    json_body: ResumeSuspendedJobJsonBody,
+) -> Response[Any]:
+    """resume a job for a suspended flow
+
+    Args:
+        workspace (str):
+        id (str):
+        json_body (ResumeSuspendedJobJsonBody):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        id=id,
+        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)

python-client/windmill-api/windmill_api/api/job/run_flow_by_path.py

@@ -0,0 +1,140 @@
+import datetime
+from typing import Any, Dict, Union
+
+import httpx
+
+from ...client import Client
+from ...models.run_flow_by_path_json_body import RunFlowByPathJsonBody
+from ...types import UNSET, Response, Unset
+
+
+def _get_kwargs(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+    json_body: RunFlowByPathJsonBody,
+    scheduled_for: Union[Unset, None, datetime.datetime] = UNSET,
+    scheduled_in_secs: Union[Unset, None, float] = UNSET,
+    parent_job: Union[Unset, None, str] = UNSET,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/jobs/run/f/{path}".format(client.base_url, workspace=workspace, path=path)
+
+    headers: Dict[str, str] = client.get_headers()
+    cookies: Dict[str, Any] = client.get_cookies()
+
+    params: Dict[str, Any] = {}
+    json_scheduled_for: Union[Unset, None, str] = UNSET
+    if not isinstance(scheduled_for, Unset):
+        json_scheduled_for = scheduled_for.isoformat() if scheduled_for else None
+
+    params["scheduled_for"] = json_scheduled_for
+
+    params["scheduled_in_secs"] = scheduled_in_secs
+
+    params["parent_job"] = parent_job
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+    json_json_body = json_body.to_dict()
+
+    return {
+        "method": "post",
+        "url": url,
+        "headers": headers,
+        "cookies": cookies,
+        "timeout": client.get_timeout(),
+        "json": json_json_body,
+        "params": params,
+    }
+
+
+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,
+    path: str,
+    *,
+    client: Client,
+    json_body: RunFlowByPathJsonBody,
+    scheduled_for: Union[Unset, None, datetime.datetime] = UNSET,
+    scheduled_in_secs: Union[Unset, None, float] = UNSET,
+    parent_job: Union[Unset, None, str] = UNSET,
+) -> Response[Any]:
+    """run flow by path
+
+    Args:
+        workspace (str):
+        path (str):
+        scheduled_for (Union[Unset, None, datetime.datetime]):
+        scheduled_in_secs (Union[Unset, None, float]):
+        parent_job (Union[Unset, None, str]):
+        json_body (RunFlowByPathJsonBody):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        client=client,
+        json_body=json_body,
+        scheduled_for=scheduled_for,
+        scheduled_in_secs=scheduled_in_secs,
+        parent_job=parent_job,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+async def asyncio_detailed(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+    json_body: RunFlowByPathJsonBody,
+    scheduled_for: Union[Unset, None, datetime.datetime] = UNSET,
+    scheduled_in_secs: Union[Unset, None, float] = UNSET,
+    parent_job: Union[Unset, None, str] = UNSET,
+) -> Response[Any]:
+    """run flow by path
+
+    Args:
+        workspace (str):
+        path (str):
+        scheduled_for (Union[Unset, None, datetime.datetime]):
+        scheduled_in_secs (Union[Unset, None, float]):
+        parent_job (Union[Unset, None, str]):
+        json_body (RunFlowByPathJsonBody):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        client=client,
+        json_body=json_body,
+        scheduled_for=scheduled_for,
+        scheduled_in_secs=scheduled_in_secs,
+        parent_job=parent_job,
+    )
+
+    async with httpx.AsyncClient(verify=client.verify_ssl) as _client:
+        response = await _client.request(**kwargs)
+
+    return _build_response(response=response)

python-client/windmill-api/windmill_api/api/job/run_flow_preview.py

@@ -0,0 +1,97 @@
+from typing import Any, Dict
+
+import httpx
+
+from ...client import Client
+from ...models.run_flow_preview_json_body import RunFlowPreviewJsonBody
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    *,
+    client: Client,
+    json_body: RunFlowPreviewJsonBody,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/jobs/run/preview_flow".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: RunFlowPreviewJsonBody,
+) -> Response[Any]:
+    """run flow preview
+
+    Args:
+        workspace (str):
+        json_body (RunFlowPreviewJsonBody):
+
+    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: RunFlowPreviewJsonBody,
+) -> Response[Any]:
+    """run flow preview
+
+    Args:
+        workspace (str):
+        json_body (RunFlowPreviewJsonBody):
+
+    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)

python-client/windmill-api/windmill_api/api/job/run_script_by_hash.py

@@ -0,0 +1,140 @@
+import datetime
+from typing import Any, Dict, Union
+
+import httpx
+
+from ...client import Client
+from ...models.run_script_by_hash_json_body import RunScriptByHashJsonBody
+from ...types import UNSET, Response, Unset
+
+
+def _get_kwargs(
+    workspace: str,
+    hash_: str,
+    *,
+    client: Client,
+    json_body: RunScriptByHashJsonBody,
+    scheduled_for: Union[Unset, None, datetime.datetime] = UNSET,
+    scheduled_in_secs: Union[Unset, None, float] = UNSET,
+    parent_job: Union[Unset, None, str] = UNSET,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/jobs/run/h/{hash}".format(client.base_url, workspace=workspace, hash=hash_)
+
+    headers: Dict[str, str] = client.get_headers()
+    cookies: Dict[str, Any] = client.get_cookies()
+
+    params: Dict[str, Any] = {}
+    json_scheduled_for: Union[Unset, None, str] = UNSET
+    if not isinstance(scheduled_for, Unset):
+        json_scheduled_for = scheduled_for.isoformat() if scheduled_for else None
+
+    params["scheduled_for"] = json_scheduled_for
+
+    params["scheduled_in_secs"] = scheduled_in_secs
+
+    params["parent_job"] = parent_job
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+    json_json_body = json_body.to_dict()
+
+    return {
+        "method": "post",
+        "url": url,
+        "headers": headers,
+        "cookies": cookies,
+        "timeout": client.get_timeout(),
+        "json": json_json_body,
+        "params": params,
+    }
+
+
+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,
+    hash_: str,
+    *,
+    client: Client,
+    json_body: RunScriptByHashJsonBody,
+    scheduled_for: Union[Unset, None, datetime.datetime] = UNSET,
+    scheduled_in_secs: Union[Unset, None, float] = UNSET,
+    parent_job: Union[Unset, None, str] = UNSET,
+) -> Response[Any]:
+    """run script by hash
+
+    Args:
+        workspace (str):
+        hash_ (str):
+        scheduled_for (Union[Unset, None, datetime.datetime]):
+        scheduled_in_secs (Union[Unset, None, float]):
+        parent_job (Union[Unset, None, str]):
+        json_body (RunScriptByHashJsonBody):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        hash_=hash_,
+        client=client,
+        json_body=json_body,
+        scheduled_for=scheduled_for,
+        scheduled_in_secs=scheduled_in_secs,
+        parent_job=parent_job,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+async def asyncio_detailed(
+    workspace: str,
+    hash_: str,
+    *,
+    client: Client,
+    json_body: RunScriptByHashJsonBody,
+    scheduled_for: Union[Unset, None, datetime.datetime] = UNSET,
+    scheduled_in_secs: Union[Unset, None, float] = UNSET,
+    parent_job: Union[Unset, None, str] = UNSET,
+) -> Response[Any]:
+    """run script by hash
+
+    Args:
+        workspace (str):
+        hash_ (str):
+        scheduled_for (Union[Unset, None, datetime.datetime]):
+        scheduled_in_secs (Union[Unset, None, float]):
+        parent_job (Union[Unset, None, str]):
+        json_body (RunScriptByHashJsonBody):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        hash_=hash_,
+        client=client,
+        json_body=json_body,
+        scheduled_for=scheduled_for,
+        scheduled_in_secs=scheduled_in_secs,
+        parent_job=parent_job,
+    )
+
+    async with httpx.AsyncClient(verify=client.verify_ssl) as _client:
+        response = await _client.request(**kwargs)
+
+    return _build_response(response=response)

python-client/windmill-api/windmill_api/api/job/run_script_by_path.py

@@ -0,0 +1,140 @@
+import datetime
+from typing import Any, Dict, Union
+
+import httpx
+
+from ...client import Client
+from ...models.run_script_by_path_json_body import RunScriptByPathJsonBody
+from ...types import UNSET, Response, Unset
+
+
+def _get_kwargs(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+    json_body: RunScriptByPathJsonBody,
+    scheduled_for: Union[Unset, None, datetime.datetime] = UNSET,
+    scheduled_in_secs: Union[Unset, None, float] = UNSET,
+    parent_job: Union[Unset, None, str] = UNSET,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/jobs/run/p/{path}".format(client.base_url, workspace=workspace, path=path)
+
+    headers: Dict[str, str] = client.get_headers()
+    cookies: Dict[str, Any] = client.get_cookies()
+
+    params: Dict[str, Any] = {}
+    json_scheduled_for: Union[Unset, None, str] = UNSET
+    if not isinstance(scheduled_for, Unset):
+        json_scheduled_for = scheduled_for.isoformat() if scheduled_for else None
+
+    params["scheduled_for"] = json_scheduled_for
+
+    params["scheduled_in_secs"] = scheduled_in_secs
+
+    params["parent_job"] = parent_job
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+    json_json_body = json_body.to_dict()
+
+    return {
+        "method": "post",
+        "url": url,
+        "headers": headers,
+        "cookies": cookies,
+        "timeout": client.get_timeout(),
+        "json": json_json_body,
+        "params": params,
+    }
+
+
+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,
+    path: str,
+    *,
+    client: Client,
+    json_body: RunScriptByPathJsonBody,
+    scheduled_for: Union[Unset, None, datetime.datetime] = UNSET,
+    scheduled_in_secs: Union[Unset, None, float] = UNSET,
+    parent_job: Union[Unset, None, str] = UNSET,
+) -> Response[Any]:
+    """run script by path
+
+    Args:
+        workspace (str):
+        path (str):
+        scheduled_for (Union[Unset, None, datetime.datetime]):
+        scheduled_in_secs (Union[Unset, None, float]):
+        parent_job (Union[Unset, None, str]):
+        json_body (RunScriptByPathJsonBody):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        client=client,
+        json_body=json_body,
+        scheduled_for=scheduled_for,
+        scheduled_in_secs=scheduled_in_secs,
+        parent_job=parent_job,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+async def asyncio_detailed(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+    json_body: RunScriptByPathJsonBody,
+    scheduled_for: Union[Unset, None, datetime.datetime] = UNSET,
+    scheduled_in_secs: Union[Unset, None, float] = UNSET,
+    parent_job: Union[Unset, None, str] = UNSET,
+) -> Response[Any]:
+    """run script by path
+
+    Args:
+        workspace (str):
+        path (str):
+        scheduled_for (Union[Unset, None, datetime.datetime]):
+        scheduled_in_secs (Union[Unset, None, float]):
+        parent_job (Union[Unset, None, str]):
+        json_body (RunScriptByPathJsonBody):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        client=client,
+        json_body=json_body,
+        scheduled_for=scheduled_for,
+        scheduled_in_secs=scheduled_in_secs,
+        parent_job=parent_job,
+    )
+
+    async with httpx.AsyncClient(verify=client.verify_ssl) as _client:
+        response = await _client.request(**kwargs)
+
+    return _build_response(response=response)

python-client/windmill-api/windmill_api/api/job/run_script_preview.py

@@ -0,0 +1,97 @@
+from typing import Any, Dict
+
+import httpx
+
+from ...client import Client
+from ...models.run_script_preview_json_body import RunScriptPreviewJsonBody
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    *,
+    client: Client,
+    json_body: RunScriptPreviewJsonBody,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/jobs/run/preview".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: RunScriptPreviewJsonBody,
+) -> Response[Any]:
+    """run script preview
+
+    Args:
+        workspace (str):
+        json_body (RunScriptPreviewJsonBody):
+
+    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: RunScriptPreviewJsonBody,
+) -> Response[Any]:
+    """run script preview
+
+    Args:
+        workspace (str):
+        json_body (RunScriptPreviewJsonBody):
+
+    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)

python-client/windmill-api/windmill_api/api/job/run_wait_result_script_by_path.py

@@ -0,0 +1,140 @@
+import datetime
+from typing import Any, Dict, Union
+
+import httpx
+
+from ...client import Client
+from ...models.run_wait_result_script_by_path_json_body import RunWaitResultScriptByPathJsonBody
+from ...types import UNSET, Response, Unset
+
+
+def _get_kwargs(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+    json_body: RunWaitResultScriptByPathJsonBody,
+    scheduled_for: Union[Unset, None, datetime.datetime] = UNSET,
+    scheduled_in_secs: Union[Unset, None, float] = UNSET,
+    parent_job: Union[Unset, None, str] = UNSET,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/jobs/run_wait_result/p/{path}".format(client.base_url, workspace=workspace, path=path)
+
+    headers: Dict[str, str] = client.get_headers()
+    cookies: Dict[str, Any] = client.get_cookies()
+
+    params: Dict[str, Any] = {}
+    json_scheduled_for: Union[Unset, None, str] = UNSET
+    if not isinstance(scheduled_for, Unset):
+        json_scheduled_for = scheduled_for.isoformat() if scheduled_for else None
+
+    params["scheduled_for"] = json_scheduled_for
+
+    params["scheduled_in_secs"] = scheduled_in_secs
+
+    params["parent_job"] = parent_job
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+    json_json_body = json_body.to_dict()
+
+    return {
+        "method": "post",
+        "url": url,
+        "headers": headers,
+        "cookies": cookies,
+        "timeout": client.get_timeout(),
+        "json": json_json_body,
+        "params": params,
+    }
+
+
+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,
+    path: str,
+    *,
+    client: Client,
+    json_body: RunWaitResultScriptByPathJsonBody,
+    scheduled_for: Union[Unset, None, datetime.datetime] = UNSET,
+    scheduled_in_secs: Union[Unset, None, float] = UNSET,
+    parent_job: Union[Unset, None, str] = UNSET,
+) -> Response[Any]:
+    """run script by path
+
+    Args:
+        workspace (str):
+        path (str):
+        scheduled_for (Union[Unset, None, datetime.datetime]):
+        scheduled_in_secs (Union[Unset, None, float]):
+        parent_job (Union[Unset, None, str]):
+        json_body (RunWaitResultScriptByPathJsonBody):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        client=client,
+        json_body=json_body,
+        scheduled_for=scheduled_for,
+        scheduled_in_secs=scheduled_in_secs,
+        parent_job=parent_job,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+async def asyncio_detailed(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+    json_body: RunWaitResultScriptByPathJsonBody,
+    scheduled_for: Union[Unset, None, datetime.datetime] = UNSET,
+    scheduled_in_secs: Union[Unset, None, float] = UNSET,
+    parent_job: Union[Unset, None, str] = UNSET,
+) -> Response[Any]:
+    """run script by path
+
+    Args:
+        workspace (str):
+        path (str):
+        scheduled_for (Union[Unset, None, datetime.datetime]):
+        scheduled_in_secs (Union[Unset, None, float]):
+        parent_job (Union[Unset, None, str]):
+        json_body (RunWaitResultScriptByPathJsonBody):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        client=client,
+        json_body=json_body,
+        scheduled_for=scheduled_for,
+        scheduled_in_secs=scheduled_in_secs,
+        parent_job=parent_job,
+    )
+
+    async with httpx.AsyncClient(verify=client.verify_ssl) as _client:
+        response = await _client.request(**kwargs)
+
+    return _build_response(response=response)

python-client/windmill-api/windmill_api/api/oauth/connect_callback.py

@@ -0,0 +1,154 @@
+from typing import Any, Dict, Optional
+
+import httpx
+
+from ...client import Client
+from ...models.connect_callback_json_body import ConnectCallbackJsonBody
+from ...models.connect_callback_response_200 import ConnectCallbackResponse200
+from ...types import Response
+
+
+def _get_kwargs(
+    client_name: str,
+    *,
+    client: Client,
+    json_body: ConnectCallbackJsonBody,
+) -> Dict[str, Any]:
+    url = "{}/oauth/connect_callback/{client_name}".format(client.base_url, client_name=client_name)
+
+    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 _parse_response(*, response: httpx.Response) -> Optional[ConnectCallbackResponse200]:
+    if response.status_code == 200:
+        response_200 = ConnectCallbackResponse200.from_dict(response.json())
+
+        return response_200
+    return None
+
+
+def _build_response(*, response: httpx.Response) -> Response[ConnectCallbackResponse200]:
+    return Response(
+        status_code=response.status_code,
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(response=response),
+    )
+
+
+def sync_detailed(
+    client_name: str,
+    *,
+    client: Client,
+    json_body: ConnectCallbackJsonBody,
+) -> Response[ConnectCallbackResponse200]:
+    """connect callback
+
+    Args:
+        client_name (str):
+        json_body (ConnectCallbackJsonBody):
+
+    Returns:
+        Response[ConnectCallbackResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        client_name=client_name,
+        client=client,
+        json_body=json_body,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+def sync(
+    client_name: str,
+    *,
+    client: Client,
+    json_body: ConnectCallbackJsonBody,
+) -> Optional[ConnectCallbackResponse200]:
+    """connect callback
+
+    Args:
+        client_name (str):
+        json_body (ConnectCallbackJsonBody):
+
+    Returns:
+        Response[ConnectCallbackResponse200]
+    """
+
+    return sync_detailed(
+        client_name=client_name,
+        client=client,
+        json_body=json_body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    client_name: str,
+    *,
+    client: Client,
+    json_body: ConnectCallbackJsonBody,
+) -> Response[ConnectCallbackResponse200]:
+    """connect callback
+
+    Args:
+        client_name (str):
+        json_body (ConnectCallbackJsonBody):
+
+    Returns:
+        Response[ConnectCallbackResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        client_name=client_name,
+        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)
+
+
+async def asyncio(
+    client_name: str,
+    *,
+    client: Client,
+    json_body: ConnectCallbackJsonBody,
+) -> Optional[ConnectCallbackResponse200]:
+    """connect callback
+
+    Args:
+        client_name (str):
+        json_body (ConnectCallbackJsonBody):
+
+    Returns:
+        Response[ConnectCallbackResponse200]
+    """
+
+    return (
+        await asyncio_detailed(
+            client_name=client_name,
+            client=client,
+            json_body=json_body,
+        )
+    ).parsed

python-client/windmill-api/windmill_api/api/oauth/connect_slack_callback.py

@@ -0,0 +1,141 @@
+from typing import Any, Dict, Optional
+
+import httpx
+
+from ...client import Client
+from ...models.connect_slack_callback_json_body import ConnectSlackCallbackJsonBody
+from ...models.connect_slack_callback_response_200 import ConnectSlackCallbackResponse200
+from ...types import Response
+
+
+def _get_kwargs(
+    *,
+    client: Client,
+    json_body: ConnectSlackCallbackJsonBody,
+) -> Dict[str, Any]:
+    url = "{}/oauth/connect_slack_callback".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 _parse_response(*, response: httpx.Response) -> Optional[ConnectSlackCallbackResponse200]:
+    if response.status_code == 200:
+        response_200 = ConnectSlackCallbackResponse200.from_dict(response.json())
+
+        return response_200
+    return None
+
+
+def _build_response(*, response: httpx.Response) -> Response[ConnectSlackCallbackResponse200]:
+    return Response(
+        status_code=response.status_code,
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: Client,
+    json_body: ConnectSlackCallbackJsonBody,
+) -> Response[ConnectSlackCallbackResponse200]:
+    """connect slack callback
+
+    Args:
+        json_body (ConnectSlackCallbackJsonBody):
+
+    Returns:
+        Response[ConnectSlackCallbackResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        client=client,
+        json_body=json_body,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+def sync(
+    *,
+    client: Client,
+    json_body: ConnectSlackCallbackJsonBody,
+) -> Optional[ConnectSlackCallbackResponse200]:
+    """connect slack callback
+
+    Args:
+        json_body (ConnectSlackCallbackJsonBody):
+
+    Returns:
+        Response[ConnectSlackCallbackResponse200]
+    """
+
+    return sync_detailed(
+        client=client,
+        json_body=json_body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: Client,
+    json_body: ConnectSlackCallbackJsonBody,
+) -> Response[ConnectSlackCallbackResponse200]:
+    """connect slack callback
+
+    Args:
+        json_body (ConnectSlackCallbackJsonBody):
+
+    Returns:
+        Response[ConnectSlackCallbackResponse200]
+    """
+
+    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)
+
+
+async def asyncio(
+    *,
+    client: Client,
+    json_body: ConnectSlackCallbackJsonBody,
+) -> Optional[ConnectSlackCallbackResponse200]:
+    """connect slack callback
+
+    Args:
+        json_body (ConnectSlackCallbackJsonBody):
+
+    Returns:
+        Response[ConnectSlackCallbackResponse200]
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+            json_body=json_body,
+        )
+    ).parsed

python-client/windmill-api/windmill_api/api/oauth/create_account.py

@@ -0,0 +1,97 @@
+from typing import Any, Dict
+
+import httpx
+
+from ...client import Client
+from ...models.create_account_json_body import CreateAccountJsonBody
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    *,
+    client: Client,
+    json_body: CreateAccountJsonBody,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/oauth/create_account".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: CreateAccountJsonBody,
+) -> Response[Any]:
+    """create OAuth account
+
+    Args:
+        workspace (str):
+        json_body (CreateAccountJsonBody):
+
+    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: CreateAccountJsonBody,
+) -> Response[Any]:
+    """create OAuth account
+
+    Args:
+        workspace (str):
+        json_body (CreateAccountJsonBody):
+
+    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)

python-client/windmill-api/windmill_api/api/oauth/disconnect_account.py

@@ -0,0 +1,93 @@
+from typing import Any, Dict
+
+import httpx
+
+from ...client import Client
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    id: str,
+    *,
+    client: Client,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/oauth/disconnect/{id}".format(client.base_url, workspace=workspace, id=id)
+
+    headers: Dict[str, str] = client.get_headers()
+    cookies: Dict[str, Any] = client.get_cookies()
+
+    return {
+        "method": "post",
+        "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,
+    id: str,
+    *,
+    client: Client,
+) -> Response[Any]:
+    """disconnect account
+
+    Args:
+        workspace (str):
+        id (str):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        id=id,
+        client=client,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+async def asyncio_detailed(
+    workspace: str,
+    id: str,
+    *,
+    client: Client,
+) -> Response[Any]:
+    """disconnect account
+
+    Args:
+        workspace (str):
+        id (str):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        id=id,
+        client=client,
+    )
+
+    async with httpx.AsyncClient(verify=client.verify_ssl) as _client:
+        response = await _client.request(**kwargs)
+
+    return _build_response(response=response)

python-client/windmill-api/windmill_api/api/oauth/disconnect_slack.py

@@ -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}/oauth/disconnect_slack".format(client.base_url, workspace=workspace)
+
+    headers: Dict[str, str] = client.get_headers()
+    cookies: Dict[str, Any] = client.get_cookies()
+
+    return {
+        "method": "post",
+        "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]:
+    """disconnect slack
+
+    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]:
+    """disconnect slack
+
+    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)

python-client/windmill-api/windmill_api/api/oauth/list_o_auth_connects.py

@@ -0,0 +1,75 @@
+from typing import Any, Dict
+
+import httpx
+
+from ...client import Client
+from ...types import Response
+
+
+def _get_kwargs(
+    *,
+    client: Client,
+) -> Dict[str, Any]:
+    url = "{}/oauth/list_connects".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 _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,
+) -> Response[Any]:
+    """list oauth connects
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        client=client,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+async def asyncio_detailed(
+    *,
+    client: Client,
+) -> Response[Any]:
+    """list oauth connects
+
+    Returns:
+        Response[Any]
+    """
+
+    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)

python-client/windmill-api/windmill_api/api/oauth/list_o_auth_logins.py

@@ -0,0 +1,115 @@
+from typing import Any, Dict, List, Optional, cast
+
+import httpx
+
+from ...client import Client
+from ...types import Response
+
+
+def _get_kwargs(
+    *,
+    client: Client,
+) -> Dict[str, Any]:
+    url = "{}/oauth/list_logins".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[str]]:
+    if response.status_code == 200:
+        response_200 = cast(List[str], response.json())
+
+        return response_200
+    return None
+
+
+def _build_response(*, response: httpx.Response) -> Response[List[str]]:
+    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[str]]:
+    """list oauth logins
+
+    Returns:
+        Response[List[str]]
+    """
+
+    kwargs = _get_kwargs(
+        client=client,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+def sync(
+    *,
+    client: Client,
+) -> Optional[List[str]]:
+    """list oauth logins
+
+    Returns:
+        Response[List[str]]
+    """
+
+    return sync_detailed(
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: Client,
+) -> Response[List[str]]:
+    """list oauth logins
+
+    Returns:
+        Response[List[str]]
+    """
+
+    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[str]]:
+    """list oauth logins
+
+    Returns:
+        Response[List[str]]
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+        )
+    ).parsed

python-client/windmill-api/windmill_api/api/oauth/refresh_token.py

@@ -0,0 +1,104 @@
+from typing import Any, Dict
+
+import httpx
+
+from ...client import Client
+from ...models.refresh_token_json_body import RefreshTokenJsonBody
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    id: str,
+    *,
+    client: Client,
+    json_body: RefreshTokenJsonBody,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/oauth/refresh_token/{id}".format(client.base_url, workspace=workspace, id=id)
+
+    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,
+    id: str,
+    *,
+    client: Client,
+    json_body: RefreshTokenJsonBody,
+) -> Response[Any]:
+    """refresh token
+
+    Args:
+        workspace (str):
+        id (str):
+        json_body (RefreshTokenJsonBody):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        id=id,
+        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,
+    id: str,
+    *,
+    client: Client,
+    json_body: RefreshTokenJsonBody,
+) -> Response[Any]:
+    """refresh token
+
+    Args:
+        workspace (str):
+        id (str):
+        json_body (RefreshTokenJsonBody):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        id=id,
+        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)

python-client/windmill-api/windmill_api/api/oauth/set_workspace_slack.py

@@ -0,0 +1,97 @@
+from typing import Any, Dict
+
+import httpx
+
+from ...client import Client
+from ...models.set_workspace_slack_json_body import SetWorkspaceSlackJsonBody
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    *,
+    client: Client,
+    json_body: SetWorkspaceSlackJsonBody,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/oauth/set_workspace_slack".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: SetWorkspaceSlackJsonBody,
+) -> Response[Any]:
+    """set workspace's slack
+
+    Args:
+        workspace (str):
+        json_body (SetWorkspaceSlackJsonBody):
+
+    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: SetWorkspaceSlackJsonBody,
+) -> Response[Any]:
+    """set workspace's slack
+
+    Args:
+        workspace (str):
+        json_body (SetWorkspaceSlackJsonBody):
+
+    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)

python-client/windmill-api/windmill_api/api/resource/create_resource.py

@@ -0,0 +1,97 @@
+from typing import Any, Dict
+
+import httpx
+
+from ...client import Client
+from ...models.create_resource_json_body import CreateResourceJsonBody
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    *,
+    client: Client,
+    json_body: CreateResourceJsonBody,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/resources/create".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: CreateResourceJsonBody,
+) -> Response[Any]:
+    """create resource
+
+    Args:
+        workspace (str):
+        json_body (CreateResourceJsonBody):
+
+    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: CreateResourceJsonBody,
+) -> Response[Any]:
+    """create resource
+
+    Args:
+        workspace (str):
+        json_body (CreateResourceJsonBody):
+
+    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)

python-client/windmill-api/windmill_api/api/resource/create_resource_type.py

@@ -0,0 +1,97 @@
+from typing import Any, Dict
+
+import httpx
+
+from ...client import Client
+from ...models.create_resource_type_json_body import CreateResourceTypeJsonBody
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    *,
+    client: Client,
+    json_body: CreateResourceTypeJsonBody,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/resources/type/create".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: CreateResourceTypeJsonBody,
+) -> Response[Any]:
+    """create resource_type
+
+    Args:
+        workspace (str):
+        json_body (CreateResourceTypeJsonBody):
+
+    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: CreateResourceTypeJsonBody,
+) -> Response[Any]:
+    """create resource_type
+
+    Args:
+        workspace (str):
+        json_body (CreateResourceTypeJsonBody):
+
+    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)

python-client/windmill-api/windmill_api/api/resource/delete_resource.py

@@ -0,0 +1,93 @@
+from typing import Any, Dict
+
+import httpx
+
+from ...client import Client
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/resources/delete/{path}".format(client.base_url, workspace=workspace, path=path)
+
+    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,
+    path: str,
+    *,
+    client: Client,
+) -> Response[Any]:
+    """delete resource
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        client=client,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+async def asyncio_detailed(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Response[Any]:
+    """delete resource
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        client=client,
+    )
+
+    async with httpx.AsyncClient(verify=client.verify_ssl) as _client:
+        response = await _client.request(**kwargs)
+
+    return _build_response(response=response)

python-client/windmill-api/windmill_api/api/resource/delete_resource_type.py

@@ -0,0 +1,93 @@
+from typing import Any, Dict
+
+import httpx
+
+from ...client import Client
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/resources/type/delete/{path}".format(client.base_url, workspace=workspace, path=path)
+
+    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,
+    path: str,
+    *,
+    client: Client,
+) -> Response[Any]:
+    """delete resource_type
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        client=client,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+async def asyncio_detailed(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Response[Any]:
+    """delete resource_type
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        client=client,
+    )
+
+    async with httpx.AsyncClient(verify=client.verify_ssl) as _client:
+        response = await _client.request(**kwargs)
+
+    return _build_response(response=response)

python-client/windmill-api/windmill_api/api/resource/exists_resource.py

@@ -0,0 +1,148 @@
+from typing import Any, Dict, Optional, cast
+
+import httpx
+
+from ...client import Client
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/resources/exists/{path}".format(client.base_url, workspace=workspace, path=path)
+
+    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[bool]:
+    if response.status_code == 200:
+        response_200 = cast(bool, response.json())
+        return response_200
+    return None
+
+
+def _build_response(*, response: httpx.Response) -> Response[bool]:
+    return Response(
+        status_code=response.status_code,
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(response=response),
+    )
+
+
+def sync_detailed(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Response[bool]:
+    """does resource exists
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[bool]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        client=client,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+def sync(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Optional[bool]:
+    """does resource exists
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[bool]
+    """
+
+    return sync_detailed(
+        workspace=workspace,
+        path=path,
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Response[bool]:
+    """does resource exists
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[bool]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        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,
+    path: str,
+    *,
+    client: Client,
+) -> Optional[bool]:
+    """does resource exists
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[bool]
+    """
+
+    return (
+        await asyncio_detailed(
+            workspace=workspace,
+            path=path,
+            client=client,
+        )
+    ).parsed

python-client/windmill-api/windmill_api/api/resource/exists_resource_type.py

@@ -0,0 +1,148 @@
+from typing import Any, Dict, Optional, cast
+
+import httpx
+
+from ...client import Client
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/resources/type/exists/{path}".format(client.base_url, workspace=workspace, path=path)
+
+    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[bool]:
+    if response.status_code == 200:
+        response_200 = cast(bool, response.json())
+        return response_200
+    return None
+
+
+def _build_response(*, response: httpx.Response) -> Response[bool]:
+    return Response(
+        status_code=response.status_code,
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(response=response),
+    )
+
+
+def sync_detailed(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Response[bool]:
+    """does resource_type exists
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[bool]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        client=client,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+def sync(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Optional[bool]:
+    """does resource_type exists
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[bool]
+    """
+
+    return sync_detailed(
+        workspace=workspace,
+        path=path,
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Response[bool]:
+    """does resource_type exists
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[bool]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        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,
+    path: str,
+    *,
+    client: Client,
+) -> Optional[bool]:
+    """does resource_type exists
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[bool]
+    """
+
+    return (
+        await asyncio_detailed(
+            workspace=workspace,
+            path=path,
+            client=client,
+        )
+    ).parsed

python-client/windmill-api/windmill_api/api/resource/get_resource.py

@@ -0,0 +1,150 @@
+from typing import Any, Dict, Optional
+
+import httpx
+
+from ...client import Client
+from ...models.get_resource_response_200 import GetResourceResponse200
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/resources/get/{path}".format(client.base_url, workspace=workspace, path=path)
+
+    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[GetResourceResponse200]:
+    if response.status_code == 200:
+        response_200 = GetResourceResponse200.from_dict(response.json())
+
+        return response_200
+    return None
+
+
+def _build_response(*, response: httpx.Response) -> Response[GetResourceResponse200]:
+    return Response(
+        status_code=response.status_code,
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(response=response),
+    )
+
+
+def sync_detailed(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Response[GetResourceResponse200]:
+    """get resource
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[GetResourceResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        client=client,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+def sync(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Optional[GetResourceResponse200]:
+    """get resource
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[GetResourceResponse200]
+    """
+
+    return sync_detailed(
+        workspace=workspace,
+        path=path,
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Response[GetResourceResponse200]:
+    """get resource
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[GetResourceResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        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,
+    path: str,
+    *,
+    client: Client,
+) -> Optional[GetResourceResponse200]:
+    """get resource
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[GetResourceResponse200]
+    """
+
+    return (
+        await asyncio_detailed(
+            workspace=workspace,
+            path=path,
+            client=client,
+        )
+    ).parsed

python-client/windmill-api/windmill_api/api/resource/get_resource_type.py

@@ -0,0 +1,150 @@
+from typing import Any, Dict, Optional
+
+import httpx
+
+from ...client import Client
+from ...models.get_resource_type_response_200 import GetResourceTypeResponse200
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/resources/type/get/{path}".format(client.base_url, workspace=workspace, path=path)
+
+    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[GetResourceTypeResponse200]:
+    if response.status_code == 200:
+        response_200 = GetResourceTypeResponse200.from_dict(response.json())
+
+        return response_200
+    return None
+
+
+def _build_response(*, response: httpx.Response) -> Response[GetResourceTypeResponse200]:
+    return Response(
+        status_code=response.status_code,
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(response=response),
+    )
+
+
+def sync_detailed(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Response[GetResourceTypeResponse200]:
+    """get resource_type
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[GetResourceTypeResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        client=client,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+def sync(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Optional[GetResourceTypeResponse200]:
+    """get resource_type
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[GetResourceTypeResponse200]
+    """
+
+    return sync_detailed(
+        workspace=workspace,
+        path=path,
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Response[GetResourceTypeResponse200]:
+    """get resource_type
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[GetResourceTypeResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        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,
+    path: str,
+    *,
+    client: Client,
+) -> Optional[GetResourceTypeResponse200]:
+    """get resource_type
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[GetResourceTypeResponse200]
+    """
+
+    return (
+        await asyncio_detailed(
+            workspace=workspace,
+            path=path,
+            client=client,
+        )
+    ).parsed

python-client/windmill-api/windmill_api/api/resource/list_resource.py

@@ -0,0 +1,191 @@
+from typing import Any, Dict, List, Optional, Union
+
+import httpx
+
+from ...client import Client
+from ...models.list_resource_response_200_item import ListResourceResponse200Item
+from ...types import UNSET, Response, Unset
+
+
+def _get_kwargs(
+    workspace: str,
+    *,
+    client: Client,
+    page: Union[Unset, None, int] = UNSET,
+    per_page: Union[Unset, None, int] = UNSET,
+    resource_type: Union[Unset, None, str] = UNSET,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/resources/list".format(client.base_url, workspace=workspace)
+
+    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["resource_type"] = resource_type
+
+    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[ListResourceResponse200Item]]:
+    if response.status_code == 200:
+        response_200 = []
+        _response_200 = response.json()
+        for response_200_item_data in _response_200:
+            response_200_item = ListResourceResponse200Item.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[ListResourceResponse200Item]]:
+    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,
+    page: Union[Unset, None, int] = UNSET,
+    per_page: Union[Unset, None, int] = UNSET,
+    resource_type: Union[Unset, None, str] = UNSET,
+) -> Response[List[ListResourceResponse200Item]]:
+    """list resources
+
+    Args:
+        workspace (str):
+        page (Union[Unset, None, int]):
+        per_page (Union[Unset, None, int]):
+        resource_type (Union[Unset, None, str]):
+
+    Returns:
+        Response[List[ListResourceResponse200Item]]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        client=client,
+        page=page,
+        per_page=per_page,
+        resource_type=resource_type,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+def sync(
+    workspace: str,
+    *,
+    client: Client,
+    page: Union[Unset, None, int] = UNSET,
+    per_page: Union[Unset, None, int] = UNSET,
+    resource_type: Union[Unset, None, str] = UNSET,
+) -> Optional[List[ListResourceResponse200Item]]:
+    """list resources
+
+    Args:
+        workspace (str):
+        page (Union[Unset, None, int]):
+        per_page (Union[Unset, None, int]):
+        resource_type (Union[Unset, None, str]):
+
+    Returns:
+        Response[List[ListResourceResponse200Item]]
+    """
+
+    return sync_detailed(
+        workspace=workspace,
+        client=client,
+        page=page,
+        per_page=per_page,
+        resource_type=resource_type,
+    ).parsed
+
+
+async def asyncio_detailed(
+    workspace: str,
+    *,
+    client: Client,
+    page: Union[Unset, None, int] = UNSET,
+    per_page: Union[Unset, None, int] = UNSET,
+    resource_type: Union[Unset, None, str] = UNSET,
+) -> Response[List[ListResourceResponse200Item]]:
+    """list resources
+
+    Args:
+        workspace (str):
+        page (Union[Unset, None, int]):
+        per_page (Union[Unset, None, int]):
+        resource_type (Union[Unset, None, str]):
+
+    Returns:
+        Response[List[ListResourceResponse200Item]]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        client=client,
+        page=page,
+        per_page=per_page,
+        resource_type=resource_type,
+    )
+
+    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,
+    page: Union[Unset, None, int] = UNSET,
+    per_page: Union[Unset, None, int] = UNSET,
+    resource_type: Union[Unset, None, str] = UNSET,
+) -> Optional[List[ListResourceResponse200Item]]:
+    """list resources
+
+    Args:
+        workspace (str):
+        page (Union[Unset, None, int]):
+        per_page (Union[Unset, None, int]):
+        resource_type (Union[Unset, None, str]):
+
+    Returns:
+        Response[List[ListResourceResponse200Item]]
+    """
+
+    return (
+        await asyncio_detailed(
+            workspace=workspace,
+            client=client,
+            page=page,
+            per_page=per_page,
+            resource_type=resource_type,
+        )
+    ).parsed

python-client/windmill-api/windmill_api/api/resource/list_resource_type.py

@@ -0,0 +1,142 @@
+from typing import Any, Dict, List, Optional
+
+import httpx
+
+from ...client import Client
+from ...models.list_resource_type_response_200_item import ListResourceTypeResponse200Item
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    *,
+    client: Client,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/resources/type/list".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[ListResourceTypeResponse200Item]]:
+    if response.status_code == 200:
+        response_200 = []
+        _response_200 = response.json()
+        for response_200_item_data in _response_200:
+            response_200_item = ListResourceTypeResponse200Item.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[ListResourceTypeResponse200Item]]:
+    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[ListResourceTypeResponse200Item]]:
+    """list resource_types
+
+    Args:
+        workspace (str):
+
+    Returns:
+        Response[List[ListResourceTypeResponse200Item]]
+    """
+
+    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[ListResourceTypeResponse200Item]]:
+    """list resource_types
+
+    Args:
+        workspace (str):
+
+    Returns:
+        Response[List[ListResourceTypeResponse200Item]]
+    """
+
+    return sync_detailed(
+        workspace=workspace,
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    workspace: str,
+    *,
+    client: Client,
+) -> Response[List[ListResourceTypeResponse200Item]]:
+    """list resource_types
+
+    Args:
+        workspace (str):
+
+    Returns:
+        Response[List[ListResourceTypeResponse200Item]]
+    """
+
+    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[ListResourceTypeResponse200Item]]:
+    """list resource_types
+
+    Args:
+        workspace (str):
+
+    Returns:
+        Response[List[ListResourceTypeResponse200Item]]
+    """
+
+    return (
+        await asyncio_detailed(
+            workspace=workspace,
+            client=client,
+        )
+    ).parsed

python-client/windmill-api/windmill_api/api/resource/list_resource_type_names.py

@@ -0,0 +1,136 @@
+from typing import Any, Dict, List, Optional, cast
+
+import httpx
+
+from ...client import Client
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    *,
+    client: Client,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/resources/type/listnames".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[str]]:
+    if response.status_code == 200:
+        response_200 = cast(List[str], response.json())
+
+        return response_200
+    return None
+
+
+def _build_response(*, response: httpx.Response) -> Response[List[str]]:
+    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[str]]:
+    """list resource_types names
+
+    Args:
+        workspace (str):
+
+    Returns:
+        Response[List[str]]
+    """
+
+    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[str]]:
+    """list resource_types names
+
+    Args:
+        workspace (str):
+
+    Returns:
+        Response[List[str]]
+    """
+
+    return sync_detailed(
+        workspace=workspace,
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    workspace: str,
+    *,
+    client: Client,
+) -> Response[List[str]]:
+    """list resource_types names
+
+    Args:
+        workspace (str):
+
+    Returns:
+        Response[List[str]]
+    """
+
+    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[str]]:
+    """list resource_types names
+
+    Args:
+        workspace (str):
+
+    Returns:
+        Response[List[str]]
+    """
+
+    return (
+        await asyncio_detailed(
+            workspace=workspace,
+            client=client,
+        )
+    ).parsed

python-client/windmill-api/windmill_api/api/resource/update_resource.py

@@ -0,0 +1,104 @@
+from typing import Any, Dict
+
+import httpx
+
+from ...client import Client
+from ...models.update_resource_json_body import UpdateResourceJsonBody
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+    json_body: UpdateResourceJsonBody,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/resources/update/{path}".format(client.base_url, workspace=workspace, path=path)
+
+    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,
+    path: str,
+    *,
+    client: Client,
+    json_body: UpdateResourceJsonBody,
+) -> Response[Any]:
+    """update resource
+
+    Args:
+        workspace (str):
+        path (str):
+        json_body (UpdateResourceJsonBody):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        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,
+    path: str,
+    *,
+    client: Client,
+    json_body: UpdateResourceJsonBody,
+) -> Response[Any]:
+    """update resource
+
+    Args:
+        workspace (str):
+        path (str):
+        json_body (UpdateResourceJsonBody):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        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)

python-client/windmill-api/windmill_api/api/resource/update_resource_type.py

@@ -0,0 +1,104 @@
+from typing import Any, Dict
+
+import httpx
+
+from ...client import Client
+from ...models.update_resource_type_json_body import UpdateResourceTypeJsonBody
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+    json_body: UpdateResourceTypeJsonBody,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/resources/type/update/{path}".format(client.base_url, workspace=workspace, path=path)
+
+    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,
+    path: str,
+    *,
+    client: Client,
+    json_body: UpdateResourceTypeJsonBody,
+) -> Response[Any]:
+    """update resource_type
+
+    Args:
+        workspace (str):
+        path (str):
+        json_body (UpdateResourceTypeJsonBody):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        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,
+    path: str,
+    *,
+    client: Client,
+    json_body: UpdateResourceTypeJsonBody,
+) -> Response[Any]:
+    """update resource_type
+
+    Args:
+        workspace (str):
+        path (str):
+        json_body (UpdateResourceTypeJsonBody):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        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)

python-client/windmill-api/windmill_api/api/schedule/create_schedule.py

@@ -0,0 +1,97 @@
+from typing import Any, Dict
+
+import httpx
+
+from ...client import Client
+from ...models.create_schedule_json_body import CreateScheduleJsonBody
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    *,
+    client: Client,
+    json_body: CreateScheduleJsonBody,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/schedules/create".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: CreateScheduleJsonBody,
+) -> Response[Any]:
+    """create schedule
+
+    Args:
+        workspace (str):
+        json_body (CreateScheduleJsonBody):
+
+    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: CreateScheduleJsonBody,
+) -> Response[Any]:
+    """create schedule
+
+    Args:
+        workspace (str):
+        json_body (CreateScheduleJsonBody):
+
+    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)

python-client/windmill-api/windmill_api/api/schedule/delete_schedule.py

@@ -0,0 +1,93 @@
+from typing import Any, Dict
+
+import httpx
+
+from ...client import Client
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/schedules/delete/{path}".format(client.base_url, workspace=workspace, path=path)
+
+    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,
+    path: str,
+    *,
+    client: Client,
+) -> Response[Any]:
+    """delete schedule
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        client=client,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+async def asyncio_detailed(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Response[Any]:
+    """delete schedule
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        client=client,
+    )
+
+    async with httpx.AsyncClient(verify=client.verify_ssl) as _client:
+        response = await _client.request(**kwargs)
+
+    return _build_response(response=response)

python-client/windmill-api/windmill_api/api/schedule/exists_schedule.py

@@ -0,0 +1,148 @@
+from typing import Any, Dict, Optional, cast
+
+import httpx
+
+from ...client import Client
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/schedules/exists/{path}".format(client.base_url, workspace=workspace, path=path)
+
+    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[bool]:
+    if response.status_code == 200:
+        response_200 = cast(bool, response.json())
+        return response_200
+    return None
+
+
+def _build_response(*, response: httpx.Response) -> Response[bool]:
+    return Response(
+        status_code=response.status_code,
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(response=response),
+    )
+
+
+def sync_detailed(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Response[bool]:
+    """does schedule exists
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[bool]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        client=client,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+def sync(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Optional[bool]:
+    """does schedule exists
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[bool]
+    """
+
+    return sync_detailed(
+        workspace=workspace,
+        path=path,
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Response[bool]:
+    """does schedule exists
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[bool]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        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,
+    path: str,
+    *,
+    client: Client,
+) -> Optional[bool]:
+    """does schedule exists
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[bool]
+    """
+
+    return (
+        await asyncio_detailed(
+            workspace=workspace,
+            path=path,
+            client=client,
+        )
+    ).parsed

python-client/windmill-api/windmill_api/api/schedule/get_schedule.py

@@ -0,0 +1,150 @@
+from typing import Any, Dict, Optional
+
+import httpx
+
+from ...client import Client
+from ...models.get_schedule_response_200 import GetScheduleResponse200
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/schedules/get/{path}".format(client.base_url, workspace=workspace, path=path)
+
+    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[GetScheduleResponse200]:
+    if response.status_code == 200:
+        response_200 = GetScheduleResponse200.from_dict(response.json())
+
+        return response_200
+    return None
+
+
+def _build_response(*, response: httpx.Response) -> Response[GetScheduleResponse200]:
+    return Response(
+        status_code=response.status_code,
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(response=response),
+    )
+
+
+def sync_detailed(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Response[GetScheduleResponse200]:
+    """get schedule
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[GetScheduleResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        client=client,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+def sync(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Optional[GetScheduleResponse200]:
+    """get schedule
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[GetScheduleResponse200]
+    """
+
+    return sync_detailed(
+        workspace=workspace,
+        path=path,
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Response[GetScheduleResponse200]:
+    """get schedule
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[GetScheduleResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        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,
+    path: str,
+    *,
+    client: Client,
+) -> Optional[GetScheduleResponse200]:
+    """get schedule
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[GetScheduleResponse200]
+    """
+
+    return (
+        await asyncio_detailed(
+            workspace=workspace,
+            path=path,
+            client=client,
+        )
+    ).parsed

python-client/windmill-api/windmill_api/api/schedule/list_schedules.py

@@ -0,0 +1,176 @@
+from typing import Any, Dict, List, Optional, Union
+
+import httpx
+
+from ...client import Client
+from ...models.list_schedules_response_200_item import ListSchedulesResponse200Item
+from ...types import UNSET, Response, Unset
+
+
+def _get_kwargs(
+    workspace: str,
+    *,
+    client: Client,
+    page: Union[Unset, None, int] = UNSET,
+    per_page: Union[Unset, None, int] = UNSET,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/schedules/list".format(client.base_url, workspace=workspace)
+
+    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[ListSchedulesResponse200Item]]:
+    if response.status_code == 200:
+        response_200 = []
+        _response_200 = response.json()
+        for response_200_item_data in _response_200:
+            response_200_item = ListSchedulesResponse200Item.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[ListSchedulesResponse200Item]]:
+    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,
+    page: Union[Unset, None, int] = UNSET,
+    per_page: Union[Unset, None, int] = UNSET,
+) -> Response[List[ListSchedulesResponse200Item]]:
+    """list schedules
+
+    Args:
+        workspace (str):
+        page (Union[Unset, None, int]):
+        per_page (Union[Unset, None, int]):
+
+    Returns:
+        Response[List[ListSchedulesResponse200Item]]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        client=client,
+        page=page,
+        per_page=per_page,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+def sync(
+    workspace: str,
+    *,
+    client: Client,
+    page: Union[Unset, None, int] = UNSET,
+    per_page: Union[Unset, None, int] = UNSET,
+) -> Optional[List[ListSchedulesResponse200Item]]:
+    """list schedules
+
+    Args:
+        workspace (str):
+        page (Union[Unset, None, int]):
+        per_page (Union[Unset, None, int]):
+
+    Returns:
+        Response[List[ListSchedulesResponse200Item]]
+    """
+
+    return sync_detailed(
+        workspace=workspace,
+        client=client,
+        page=page,
+        per_page=per_page,
+    ).parsed
+
+
+async def asyncio_detailed(
+    workspace: str,
+    *,
+    client: Client,
+    page: Union[Unset, None, int] = UNSET,
+    per_page: Union[Unset, None, int] = UNSET,
+) -> Response[List[ListSchedulesResponse200Item]]:
+    """list schedules
+
+    Args:
+        workspace (str):
+        page (Union[Unset, None, int]):
+        per_page (Union[Unset, None, int]):
+
+    Returns:
+        Response[List[ListSchedulesResponse200Item]]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        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(
+    workspace: str,
+    *,
+    client: Client,
+    page: Union[Unset, None, int] = UNSET,
+    per_page: Union[Unset, None, int] = UNSET,
+) -> Optional[List[ListSchedulesResponse200Item]]:
+    """list schedules
+
+    Args:
+        workspace (str):
+        page (Union[Unset, None, int]):
+        per_page (Union[Unset, None, int]):
+
+    Returns:
+        Response[List[ListSchedulesResponse200Item]]
+    """
+
+    return (
+        await asyncio_detailed(
+            workspace=workspace,
+            client=client,
+            page=page,
+            per_page=per_page,
+        )
+    ).parsed

python-client/windmill-api/windmill_api/api/schedule/preview_schedule.py

@@ -0,0 +1,147 @@
+import datetime
+from typing import Any, Dict, List, Optional
+
+import httpx
+from dateutil.parser import isoparse
+
+from ...client import Client
+from ...models.preview_schedule_json_body import PreviewScheduleJsonBody
+from ...types import Response
+
+
+def _get_kwargs(
+    *,
+    client: Client,
+    json_body: PreviewScheduleJsonBody,
+) -> Dict[str, Any]:
+    url = "{}/schedules/preview".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 _parse_response(*, response: httpx.Response) -> Optional[List[datetime.datetime]]:
+    if response.status_code == 200:
+        response_200 = []
+        _response_200 = response.json()
+        for response_200_item_data in _response_200:
+            response_200_item = isoparse(response_200_item_data)
+
+            response_200.append(response_200_item)
+
+        return response_200
+    return None
+
+
+def _build_response(*, response: httpx.Response) -> Response[List[datetime.datetime]]:
+    return Response(
+        status_code=response.status_code,
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: Client,
+    json_body: PreviewScheduleJsonBody,
+) -> Response[List[datetime.datetime]]:
+    """preview schedule
+
+    Args:
+        json_body (PreviewScheduleJsonBody):
+
+    Returns:
+        Response[List[datetime.datetime]]
+    """
+
+    kwargs = _get_kwargs(
+        client=client,
+        json_body=json_body,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+def sync(
+    *,
+    client: Client,
+    json_body: PreviewScheduleJsonBody,
+) -> Optional[List[datetime.datetime]]:
+    """preview schedule
+
+    Args:
+        json_body (PreviewScheduleJsonBody):
+
+    Returns:
+        Response[List[datetime.datetime]]
+    """
+
+    return sync_detailed(
+        client=client,
+        json_body=json_body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: Client,
+    json_body: PreviewScheduleJsonBody,
+) -> Response[List[datetime.datetime]]:
+    """preview schedule
+
+    Args:
+        json_body (PreviewScheduleJsonBody):
+
+    Returns:
+        Response[List[datetime.datetime]]
+    """
+
+    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)
+
+
+async def asyncio(
+    *,
+    client: Client,
+    json_body: PreviewScheduleJsonBody,
+) -> Optional[List[datetime.datetime]]:
+    """preview schedule
+
+    Args:
+        json_body (PreviewScheduleJsonBody):
+
+    Returns:
+        Response[List[datetime.datetime]]
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+            json_body=json_body,
+        )
+    ).parsed

python-client/windmill-api/windmill_api/api/schedule/set_schedule_enabled.py

@@ -0,0 +1,104 @@
+from typing import Any, Dict
+
+import httpx
+
+from ...client import Client
+from ...models.set_schedule_enabled_json_body import SetScheduleEnabledJsonBody
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+    json_body: SetScheduleEnabledJsonBody,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/schedules/setenabled/{path}".format(client.base_url, workspace=workspace, path=path)
+
+    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,
+    path: str,
+    *,
+    client: Client,
+    json_body: SetScheduleEnabledJsonBody,
+) -> Response[Any]:
+    """set enabled schedule
+
+    Args:
+        workspace (str):
+        path (str):
+        json_body (SetScheduleEnabledJsonBody):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        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,
+    path: str,
+    *,
+    client: Client,
+    json_body: SetScheduleEnabledJsonBody,
+) -> Response[Any]:
+    """set enabled schedule
+
+    Args:
+        workspace (str):
+        path (str):
+        json_body (SetScheduleEnabledJsonBody):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        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)

python-client/windmill-api/windmill_api/api/schedule/update_schedule.py

@@ -0,0 +1,104 @@
+from typing import Any, Dict
+
+import httpx
+
+from ...client import Client
+from ...models.update_schedule_json_body import UpdateScheduleJsonBody
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+    json_body: UpdateScheduleJsonBody,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/schedules/update/{path}".format(client.base_url, workspace=workspace, path=path)
+
+    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,
+    path: str,
+    *,
+    client: Client,
+    json_body: UpdateScheduleJsonBody,
+) -> Response[Any]:
+    """update schedule
+
+    Args:
+        workspace (str):
+        path (str):
+        json_body (UpdateScheduleJsonBody):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        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,
+    path: str,
+    *,
+    client: Client,
+    json_body: UpdateScheduleJsonBody,
+) -> Response[Any]:
+    """update schedule
+
+    Args:
+        workspace (str):
+        path (str):
+        json_body (UpdateScheduleJsonBody):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        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)

python-client/windmill-api/windmill_api/api/script/archive_script_by_hash.py

@@ -0,0 +1,150 @@
+from typing import Any, Dict, Optional
+
+import httpx
+
+from ...client import Client
+from ...models.archive_script_by_hash_response_200 import ArchiveScriptByHashResponse200
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    hash_: str,
+    *,
+    client: Client,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/scripts/archive/h/{hash}".format(client.base_url, workspace=workspace, hash=hash_)
+
+    headers: Dict[str, str] = client.get_headers()
+    cookies: Dict[str, Any] = client.get_cookies()
+
+    return {
+        "method": "post",
+        "url": url,
+        "headers": headers,
+        "cookies": cookies,
+        "timeout": client.get_timeout(),
+    }
+
+
+def _parse_response(*, response: httpx.Response) -> Optional[ArchiveScriptByHashResponse200]:
+    if response.status_code == 200:
+        response_200 = ArchiveScriptByHashResponse200.from_dict(response.json())
+
+        return response_200
+    return None
+
+
+def _build_response(*, response: httpx.Response) -> Response[ArchiveScriptByHashResponse200]:
+    return Response(
+        status_code=response.status_code,
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(response=response),
+    )
+
+
+def sync_detailed(
+    workspace: str,
+    hash_: str,
+    *,
+    client: Client,
+) -> Response[ArchiveScriptByHashResponse200]:
+    """archive script by hash
+
+    Args:
+        workspace (str):
+        hash_ (str):
+
+    Returns:
+        Response[ArchiveScriptByHashResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        hash_=hash_,
+        client=client,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+def sync(
+    workspace: str,
+    hash_: str,
+    *,
+    client: Client,
+) -> Optional[ArchiveScriptByHashResponse200]:
+    """archive script by hash
+
+    Args:
+        workspace (str):
+        hash_ (str):
+
+    Returns:
+        Response[ArchiveScriptByHashResponse200]
+    """
+
+    return sync_detailed(
+        workspace=workspace,
+        hash_=hash_,
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    workspace: str,
+    hash_: str,
+    *,
+    client: Client,
+) -> Response[ArchiveScriptByHashResponse200]:
+    """archive script by hash
+
+    Args:
+        workspace (str):
+        hash_ (str):
+
+    Returns:
+        Response[ArchiveScriptByHashResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        hash_=hash_,
+        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,
+    hash_: str,
+    *,
+    client: Client,
+) -> Optional[ArchiveScriptByHashResponse200]:
+    """archive script by hash
+
+    Args:
+        workspace (str):
+        hash_ (str):
+
+    Returns:
+        Response[ArchiveScriptByHashResponse200]
+    """
+
+    return (
+        await asyncio_detailed(
+            workspace=workspace,
+            hash_=hash_,
+            client=client,
+        )
+    ).parsed

python-client/windmill-api/windmill_api/api/script/archive_script_by_path.py

@@ -0,0 +1,93 @@
+from typing import Any, Dict
+
+import httpx
+
+from ...client import Client
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/scripts/archive/p/{path}".format(client.base_url, workspace=workspace, path=path)
+
+    headers: Dict[str, str] = client.get_headers()
+    cookies: Dict[str, Any] = client.get_cookies()
+
+    return {
+        "method": "post",
+        "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,
+    path: str,
+    *,
+    client: Client,
+) -> Response[Any]:
+    """archive script by path
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        client=client,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+async def asyncio_detailed(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Response[Any]:
+    """archive script by path
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        client=client,
+    )
+
+    async with httpx.AsyncClient(verify=client.verify_ssl) as _client:
+        response = await _client.request(**kwargs)
+
+    return _build_response(response=response)

python-client/windmill-api/windmill_api/api/script/create_script.py

@@ -0,0 +1,97 @@
+from typing import Any, Dict
+
+import httpx
+
+from ...client import Client
+from ...models.create_script_json_body import CreateScriptJsonBody
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    *,
+    client: Client,
+    json_body: CreateScriptJsonBody,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/scripts/create".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: CreateScriptJsonBody,
+) -> Response[Any]:
+    """create script
+
+    Args:
+        workspace (str):
+        json_body (CreateScriptJsonBody):
+
+    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: CreateScriptJsonBody,
+) -> Response[Any]:
+    """create script
+
+    Args:
+        workspace (str):
+        json_body (CreateScriptJsonBody):
+
+    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)

python-client/windmill-api/windmill_api/api/script/delete_script_by_hash.py

@@ -0,0 +1,150 @@
+from typing import Any, Dict, Optional
+
+import httpx
+
+from ...client import Client
+from ...models.delete_script_by_hash_response_200 import DeleteScriptByHashResponse200
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    hash_: str,
+    *,
+    client: Client,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/scripts/delete/h/{hash}".format(client.base_url, workspace=workspace, hash=hash_)
+
+    headers: Dict[str, str] = client.get_headers()
+    cookies: Dict[str, Any] = client.get_cookies()
+
+    return {
+        "method": "post",
+        "url": url,
+        "headers": headers,
+        "cookies": cookies,
+        "timeout": client.get_timeout(),
+    }
+
+
+def _parse_response(*, response: httpx.Response) -> Optional[DeleteScriptByHashResponse200]:
+    if response.status_code == 200:
+        response_200 = DeleteScriptByHashResponse200.from_dict(response.json())
+
+        return response_200
+    return None
+
+
+def _build_response(*, response: httpx.Response) -> Response[DeleteScriptByHashResponse200]:
+    return Response(
+        status_code=response.status_code,
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(response=response),
+    )
+
+
+def sync_detailed(
+    workspace: str,
+    hash_: str,
+    *,
+    client: Client,
+) -> Response[DeleteScriptByHashResponse200]:
+    """delete script by hash (erase content but keep hash)
+
+    Args:
+        workspace (str):
+        hash_ (str):
+
+    Returns:
+        Response[DeleteScriptByHashResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        hash_=hash_,
+        client=client,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+def sync(
+    workspace: str,
+    hash_: str,
+    *,
+    client: Client,
+) -> Optional[DeleteScriptByHashResponse200]:
+    """delete script by hash (erase content but keep hash)
+
+    Args:
+        workspace (str):
+        hash_ (str):
+
+    Returns:
+        Response[DeleteScriptByHashResponse200]
+    """
+
+    return sync_detailed(
+        workspace=workspace,
+        hash_=hash_,
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    workspace: str,
+    hash_: str,
+    *,
+    client: Client,
+) -> Response[DeleteScriptByHashResponse200]:
+    """delete script by hash (erase content but keep hash)
+
+    Args:
+        workspace (str):
+        hash_ (str):
+
+    Returns:
+        Response[DeleteScriptByHashResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        hash_=hash_,
+        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,
+    hash_: str,
+    *,
+    client: Client,
+) -> Optional[DeleteScriptByHashResponse200]:
+    """delete script by hash (erase content but keep hash)
+
+    Args:
+        workspace (str):
+        hash_ (str):
+
+    Returns:
+        Response[DeleteScriptByHashResponse200]
+    """
+
+    return (
+        await asyncio_detailed(
+            workspace=workspace,
+            hash_=hash_,
+            client=client,
+        )
+    ).parsed

python-client/windmill-api/windmill_api/api/script/deno_to_jsonschema.py

@@ -0,0 +1,140 @@
+from typing import Any, Dict, Optional
+
+import httpx
+
+from ...client import Client
+from ...models.deno_to_jsonschema_response_200 import DenoToJsonschemaResponse200
+from ...types import Response
+
+
+def _get_kwargs(
+    *,
+    client: Client,
+    json_body: str,
+) -> Dict[str, Any]:
+    url = "{}/scripts/deno/tojsonschema".format(client.base_url)
+
+    headers: Dict[str, str] = client.get_headers()
+    cookies: Dict[str, Any] = client.get_cookies()
+
+    json_json_body = json_body
+
+    return {
+        "method": "post",
+        "url": url,
+        "headers": headers,
+        "cookies": cookies,
+        "timeout": client.get_timeout(),
+        "json": json_json_body,
+    }
+
+
+def _parse_response(*, response: httpx.Response) -> Optional[DenoToJsonschemaResponse200]:
+    if response.status_code == 200:
+        response_200 = DenoToJsonschemaResponse200.from_dict(response.json())
+
+        return response_200
+    return None
+
+
+def _build_response(*, response: httpx.Response) -> Response[DenoToJsonschemaResponse200]:
+    return Response(
+        status_code=response.status_code,
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: Client,
+    json_body: str,
+) -> Response[DenoToJsonschemaResponse200]:
+    """inspect deno code to infer jsonschema of arguments
+
+    Args:
+        json_body (str):
+
+    Returns:
+        Response[DenoToJsonschemaResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        client=client,
+        json_body=json_body,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+def sync(
+    *,
+    client: Client,
+    json_body: str,
+) -> Optional[DenoToJsonschemaResponse200]:
+    """inspect deno code to infer jsonschema of arguments
+
+    Args:
+        json_body (str):
+
+    Returns:
+        Response[DenoToJsonschemaResponse200]
+    """
+
+    return sync_detailed(
+        client=client,
+        json_body=json_body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: Client,
+    json_body: str,
+) -> Response[DenoToJsonschemaResponse200]:
+    """inspect deno code to infer jsonschema of arguments
+
+    Args:
+        json_body (str):
+
+    Returns:
+        Response[DenoToJsonschemaResponse200]
+    """
+
+    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)
+
+
+async def asyncio(
+    *,
+    client: Client,
+    json_body: str,
+) -> Optional[DenoToJsonschemaResponse200]:
+    """inspect deno code to infer jsonschema of arguments
+
+    Args:
+        json_body (str):
+
+    Returns:
+        Response[DenoToJsonschemaResponse200]
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+            json_body=json_body,
+        )
+    ).parsed

python-client/windmill-api/windmill_api/api/script/exists_script_by_path.py

@@ -0,0 +1,148 @@
+from typing import Any, Dict, Optional, cast
+
+import httpx
+
+from ...client import Client
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/scripts/exists/p/{path}".format(client.base_url, workspace=workspace, path=path)
+
+    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[bool]:
+    if response.status_code == 200:
+        response_200 = cast(bool, response.json())
+        return response_200
+    return None
+
+
+def _build_response(*, response: httpx.Response) -> Response[bool]:
+    return Response(
+        status_code=response.status_code,
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(response=response),
+    )
+
+
+def sync_detailed(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Response[bool]:
+    """exists script by path
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[bool]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        client=client,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+def sync(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Optional[bool]:
+    """exists script by path
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[bool]
+    """
+
+    return sync_detailed(
+        workspace=workspace,
+        path=path,
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Response[bool]:
+    """exists script by path
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[bool]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        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,
+    path: str,
+    *,
+    client: Client,
+) -> Optional[bool]:
+    """exists script by path
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[bool]
+    """
+
+    return (
+        await asyncio_detailed(
+            workspace=workspace,
+            path=path,
+            client=client,
+        )
+    ).parsed

python-client/windmill-api/windmill_api/api/script/get_hub_script_content_by_path.py

@@ -0,0 +1,86 @@
+from typing import Any, Dict
+
+import httpx
+
+from ...client import Client
+from ...types import Response
+
+
+def _get_kwargs(
+    path: str,
+    *,
+    client: Client,
+) -> Dict[str, Any]:
+    url = "{}/scripts/hub/get/{path}".format(client.base_url, path=path)
+
+    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 _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(
+    path: str,
+    *,
+    client: Client,
+) -> Response[Any]:
+    """get hub script content by path
+
+    Args:
+        path (str):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        path=path,
+        client=client,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+async def asyncio_detailed(
+    path: str,
+    *,
+    client: Client,
+) -> Response[Any]:
+    """get hub script content by path
+
+    Args:
+        path (str):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        path=path,
+        client=client,
+    )
+
+    async with httpx.AsyncClient(verify=client.verify_ssl) as _client:
+        response = await _client.request(**kwargs)
+
+    return _build_response(response=response)

python-client/windmill-api/windmill_api/api/script/get_script_by_hash.py

@@ -0,0 +1,150 @@
+from typing import Any, Dict, Optional
+
+import httpx
+
+from ...client import Client
+from ...models.get_script_by_hash_response_200 import GetScriptByHashResponse200
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    hash_: str,
+    *,
+    client: Client,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/scripts/get/h/{hash}".format(client.base_url, workspace=workspace, hash=hash_)
+
+    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[GetScriptByHashResponse200]:
+    if response.status_code == 200:
+        response_200 = GetScriptByHashResponse200.from_dict(response.json())
+
+        return response_200
+    return None
+
+
+def _build_response(*, response: httpx.Response) -> Response[GetScriptByHashResponse200]:
+    return Response(
+        status_code=response.status_code,
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(response=response),
+    )
+
+
+def sync_detailed(
+    workspace: str,
+    hash_: str,
+    *,
+    client: Client,
+) -> Response[GetScriptByHashResponse200]:
+    """get script by hash
+
+    Args:
+        workspace (str):
+        hash_ (str):
+
+    Returns:
+        Response[GetScriptByHashResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        hash_=hash_,
+        client=client,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+def sync(
+    workspace: str,
+    hash_: str,
+    *,
+    client: Client,
+) -> Optional[GetScriptByHashResponse200]:
+    """get script by hash
+
+    Args:
+        workspace (str):
+        hash_ (str):
+
+    Returns:
+        Response[GetScriptByHashResponse200]
+    """
+
+    return sync_detailed(
+        workspace=workspace,
+        hash_=hash_,
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    workspace: str,
+    hash_: str,
+    *,
+    client: Client,
+) -> Response[GetScriptByHashResponse200]:
+    """get script by hash
+
+    Args:
+        workspace (str):
+        hash_ (str):
+
+    Returns:
+        Response[GetScriptByHashResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        hash_=hash_,
+        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,
+    hash_: str,
+    *,
+    client: Client,
+) -> Optional[GetScriptByHashResponse200]:
+    """get script by hash
+
+    Args:
+        workspace (str):
+        hash_ (str):
+
+    Returns:
+        Response[GetScriptByHashResponse200]
+    """
+
+    return (
+        await asyncio_detailed(
+            workspace=workspace,
+            hash_=hash_,
+            client=client,
+        )
+    ).parsed

python-client/windmill-api/windmill_api/api/script/get_script_by_path.py

@@ -0,0 +1,150 @@
+from typing import Any, Dict, Optional
+
+import httpx
+
+from ...client import Client
+from ...models.get_script_by_path_response_200 import GetScriptByPathResponse200
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/scripts/get/p/{path}".format(client.base_url, workspace=workspace, path=path)
+
+    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[GetScriptByPathResponse200]:
+    if response.status_code == 200:
+        response_200 = GetScriptByPathResponse200.from_dict(response.json())
+
+        return response_200
+    return None
+
+
+def _build_response(*, response: httpx.Response) -> Response[GetScriptByPathResponse200]:
+    return Response(
+        status_code=response.status_code,
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(response=response),
+    )
+
+
+def sync_detailed(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Response[GetScriptByPathResponse200]:
+    """get script by path
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[GetScriptByPathResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        client=client,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+def sync(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Optional[GetScriptByPathResponse200]:
+    """get script by path
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[GetScriptByPathResponse200]
+    """
+
+    return sync_detailed(
+        workspace=workspace,
+        path=path,
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Response[GetScriptByPathResponse200]:
+    """get script by path
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[GetScriptByPathResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        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,
+    path: str,
+    *,
+    client: Client,
+) -> Optional[GetScriptByPathResponse200]:
+    """get script by path
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[GetScriptByPathResponse200]
+    """
+
+    return (
+        await asyncio_detailed(
+            workspace=workspace,
+            path=path,
+            client=client,
+        )
+    ).parsed

python-client/windmill-api/windmill_api/api/script/get_script_deployment_status.py

@@ -0,0 +1,150 @@
+from typing import Any, Dict, Optional
+
+import httpx
+
+from ...client import Client
+from ...models.get_script_deployment_status_response_200 import GetScriptDeploymentStatusResponse200
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    hash_: str,
+    *,
+    client: Client,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/scripts/deployment_status/h/{hash}".format(client.base_url, workspace=workspace, hash=hash_)
+
+    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[GetScriptDeploymentStatusResponse200]:
+    if response.status_code == 200:
+        response_200 = GetScriptDeploymentStatusResponse200.from_dict(response.json())
+
+        return response_200
+    return None
+
+
+def _build_response(*, response: httpx.Response) -> Response[GetScriptDeploymentStatusResponse200]:
+    return Response(
+        status_code=response.status_code,
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(response=response),
+    )
+
+
+def sync_detailed(
+    workspace: str,
+    hash_: str,
+    *,
+    client: Client,
+) -> Response[GetScriptDeploymentStatusResponse200]:
+    """get script deployment status
+
+    Args:
+        workspace (str):
+        hash_ (str):
+
+    Returns:
+        Response[GetScriptDeploymentStatusResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        hash_=hash_,
+        client=client,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+def sync(
+    workspace: str,
+    hash_: str,
+    *,
+    client: Client,
+) -> Optional[GetScriptDeploymentStatusResponse200]:
+    """get script deployment status
+
+    Args:
+        workspace (str):
+        hash_ (str):
+
+    Returns:
+        Response[GetScriptDeploymentStatusResponse200]
+    """
+
+    return sync_detailed(
+        workspace=workspace,
+        hash_=hash_,
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    workspace: str,
+    hash_: str,
+    *,
+    client: Client,
+) -> Response[GetScriptDeploymentStatusResponse200]:
+    """get script deployment status
+
+    Args:
+        workspace (str):
+        hash_ (str):
+
+    Returns:
+        Response[GetScriptDeploymentStatusResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        hash_=hash_,
+        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,
+    hash_: str,
+    *,
+    client: Client,
+) -> Optional[GetScriptDeploymentStatusResponse200]:
+    """get script deployment status
+
+    Args:
+        workspace (str):
+        hash_ (str):
+
+    Returns:
+        Response[GetScriptDeploymentStatusResponse200]
+    """
+
+    return (
+        await asyncio_detailed(
+            workspace=workspace,
+            hash_=hash_,
+            client=client,
+        )
+    ).parsed

python-client/windmill-api/windmill_api/api/script/go_to_jsonschema.py

@@ -0,0 +1,140 @@
+from typing import Any, Dict, Optional
+
+import httpx
+
+from ...client import Client
+from ...models.go_to_jsonschema_response_200 import GoToJsonschemaResponse200
+from ...types import Response
+
+
+def _get_kwargs(
+    *,
+    client: Client,
+    json_body: str,
+) -> Dict[str, Any]:
+    url = "{}/scripts/go/tojsonschema".format(client.base_url)
+
+    headers: Dict[str, str] = client.get_headers()
+    cookies: Dict[str, Any] = client.get_cookies()
+
+    json_json_body = json_body
+
+    return {
+        "method": "post",
+        "url": url,
+        "headers": headers,
+        "cookies": cookies,
+        "timeout": client.get_timeout(),
+        "json": json_json_body,
+    }
+
+
+def _parse_response(*, response: httpx.Response) -> Optional[GoToJsonschemaResponse200]:
+    if response.status_code == 200:
+        response_200 = GoToJsonschemaResponse200.from_dict(response.json())
+
+        return response_200
+    return None
+
+
+def _build_response(*, response: httpx.Response) -> Response[GoToJsonschemaResponse200]:
+    return Response(
+        status_code=response.status_code,
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: Client,
+    json_body: str,
+) -> Response[GoToJsonschemaResponse200]:
+    """inspect go code to infer jsonschema of arguments
+
+    Args:
+        json_body (str):
+
+    Returns:
+        Response[GoToJsonschemaResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        client=client,
+        json_body=json_body,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+def sync(
+    *,
+    client: Client,
+    json_body: str,
+) -> Optional[GoToJsonschemaResponse200]:
+    """inspect go code to infer jsonschema of arguments
+
+    Args:
+        json_body (str):
+
+    Returns:
+        Response[GoToJsonschemaResponse200]
+    """
+
+    return sync_detailed(
+        client=client,
+        json_body=json_body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: Client,
+    json_body: str,
+) -> Response[GoToJsonschemaResponse200]:
+    """inspect go code to infer jsonschema of arguments
+
+    Args:
+        json_body (str):
+
+    Returns:
+        Response[GoToJsonschemaResponse200]
+    """
+
+    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)
+
+
+async def asyncio(
+    *,
+    client: Client,
+    json_body: str,
+) -> Optional[GoToJsonschemaResponse200]:
+    """inspect go code to infer jsonschema of arguments
+
+    Args:
+        json_body (str):
+
+    Returns:
+        Response[GoToJsonschemaResponse200]
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+            json_body=json_body,
+        )
+    ).parsed

python-client/windmill-api/windmill_api/api/script/list_hub_scripts.py

@@ -0,0 +1,116 @@
+from typing import Any, Dict, Optional
+
+import httpx
+
+from ...client import Client
+from ...models.list_hub_scripts_response_200 import ListHubScriptsResponse200
+from ...types import Response
+
+
+def _get_kwargs(
+    *,
+    client: Client,
+) -> Dict[str, Any]:
+    url = "{}/scripts/hub/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[ListHubScriptsResponse200]:
+    if response.status_code == 200:
+        response_200 = ListHubScriptsResponse200.from_dict(response.json())
+
+        return response_200
+    return None
+
+
+def _build_response(*, response: httpx.Response) -> Response[ListHubScriptsResponse200]:
+    return Response(
+        status_code=response.status_code,
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: Client,
+) -> Response[ListHubScriptsResponse200]:
+    """list all available hub scripts
+
+    Returns:
+        Response[ListHubScriptsResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        client=client,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+def sync(
+    *,
+    client: Client,
+) -> Optional[ListHubScriptsResponse200]:
+    """list all available hub scripts
+
+    Returns:
+        Response[ListHubScriptsResponse200]
+    """
+
+    return sync_detailed(
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: Client,
+) -> Response[ListHubScriptsResponse200]:
+    """list all available hub scripts
+
+    Returns:
+        Response[ListHubScriptsResponse200]
+    """
+
+    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[ListHubScriptsResponse200]:
+    """list all available hub scripts
+
+    Returns:
+        Response[ListHubScriptsResponse200]
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+        )
+    ).parsed

python-client/windmill-api/windmill_api/api/script/list_scripts.py

@@ -0,0 +1,326 @@
+from typing import Any, Dict, List, Optional, Union
+
+import httpx
+
+from ...client import Client
+from ...models.list_scripts_response_200_item import ListScriptsResponse200Item
+from ...types import UNSET, Response, Unset
+
+
+def _get_kwargs(
+    workspace: str,
+    *,
+    client: Client,
+    page: Union[Unset, None, int] = UNSET,
+    per_page: Union[Unset, None, int] = UNSET,
+    order_desc: Union[Unset, None, bool] = UNSET,
+    created_by: Union[Unset, None, str] = UNSET,
+    path_start: Union[Unset, None, str] = UNSET,
+    path_exact: Union[Unset, None, str] = UNSET,
+    first_parent_hash: Union[Unset, None, str] = UNSET,
+    last_parent_hash: Union[Unset, None, str] = UNSET,
+    parent_hash: Union[Unset, None, str] = UNSET,
+    show_archived: Union[Unset, None, bool] = UNSET,
+    is_template: Union[Unset, None, bool] = UNSET,
+    kind: Union[Unset, None, str] = UNSET,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/scripts/list".format(client.base_url, workspace=workspace)
+
+    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["order_desc"] = order_desc
+
+    params["created_by"] = created_by
+
+    params["path_start"] = path_start
+
+    params["path_exact"] = path_exact
+
+    params["first_parent_hash"] = first_parent_hash
+
+    params["last_parent_hash"] = last_parent_hash
+
+    params["parent_hash"] = parent_hash
+
+    params["show_archived"] = show_archived
+
+    params["is_template"] = is_template
+
+    params["kind"] = kind
+
+    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[ListScriptsResponse200Item]]:
+    if response.status_code == 200:
+        response_200 = []
+        _response_200 = response.json()
+        for response_200_item_data in _response_200:
+            response_200_item = ListScriptsResponse200Item.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[ListScriptsResponse200Item]]:
+    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,
+    page: Union[Unset, None, int] = UNSET,
+    per_page: Union[Unset, None, int] = UNSET,
+    order_desc: Union[Unset, None, bool] = UNSET,
+    created_by: Union[Unset, None, str] = UNSET,
+    path_start: Union[Unset, None, str] = UNSET,
+    path_exact: Union[Unset, None, str] = UNSET,
+    first_parent_hash: Union[Unset, None, str] = UNSET,
+    last_parent_hash: Union[Unset, None, str] = UNSET,
+    parent_hash: Union[Unset, None, str] = UNSET,
+    show_archived: Union[Unset, None, bool] = UNSET,
+    is_template: Union[Unset, None, bool] = UNSET,
+    kind: Union[Unset, None, str] = UNSET,
+) -> Response[List[ListScriptsResponse200Item]]:
+    """list all available scripts
+
+    Args:
+        workspace (str):
+        page (Union[Unset, None, int]):
+        per_page (Union[Unset, None, int]):
+        order_desc (Union[Unset, None, bool]):
+        created_by (Union[Unset, None, str]):
+        path_start (Union[Unset, None, str]):
+        path_exact (Union[Unset, None, str]):
+        first_parent_hash (Union[Unset, None, str]):
+        last_parent_hash (Union[Unset, None, str]):
+        parent_hash (Union[Unset, None, str]):
+        show_archived (Union[Unset, None, bool]):
+        is_template (Union[Unset, None, bool]):
+        kind (Union[Unset, None, str]):
+
+    Returns:
+        Response[List[ListScriptsResponse200Item]]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        client=client,
+        page=page,
+        per_page=per_page,
+        order_desc=order_desc,
+        created_by=created_by,
+        path_start=path_start,
+        path_exact=path_exact,
+        first_parent_hash=first_parent_hash,
+        last_parent_hash=last_parent_hash,
+        parent_hash=parent_hash,
+        show_archived=show_archived,
+        is_template=is_template,
+        kind=kind,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+def sync(
+    workspace: str,
+    *,
+    client: Client,
+    page: Union[Unset, None, int] = UNSET,
+    per_page: Union[Unset, None, int] = UNSET,
+    order_desc: Union[Unset, None, bool] = UNSET,
+    created_by: Union[Unset, None, str] = UNSET,
+    path_start: Union[Unset, None, str] = UNSET,
+    path_exact: Union[Unset, None, str] = UNSET,
+    first_parent_hash: Union[Unset, None, str] = UNSET,
+    last_parent_hash: Union[Unset, None, str] = UNSET,
+    parent_hash: Union[Unset, None, str] = UNSET,
+    show_archived: Union[Unset, None, bool] = UNSET,
+    is_template: Union[Unset, None, bool] = UNSET,
+    kind: Union[Unset, None, str] = UNSET,
+) -> Optional[List[ListScriptsResponse200Item]]:
+    """list all available scripts
+
+    Args:
+        workspace (str):
+        page (Union[Unset, None, int]):
+        per_page (Union[Unset, None, int]):
+        order_desc (Union[Unset, None, bool]):
+        created_by (Union[Unset, None, str]):
+        path_start (Union[Unset, None, str]):
+        path_exact (Union[Unset, None, str]):
+        first_parent_hash (Union[Unset, None, str]):
+        last_parent_hash (Union[Unset, None, str]):
+        parent_hash (Union[Unset, None, str]):
+        show_archived (Union[Unset, None, bool]):
+        is_template (Union[Unset, None, bool]):
+        kind (Union[Unset, None, str]):
+
+    Returns:
+        Response[List[ListScriptsResponse200Item]]
+    """
+
+    return sync_detailed(
+        workspace=workspace,
+        client=client,
+        page=page,
+        per_page=per_page,
+        order_desc=order_desc,
+        created_by=created_by,
+        path_start=path_start,
+        path_exact=path_exact,
+        first_parent_hash=first_parent_hash,
+        last_parent_hash=last_parent_hash,
+        parent_hash=parent_hash,
+        show_archived=show_archived,
+        is_template=is_template,
+        kind=kind,
+    ).parsed
+
+
+async def asyncio_detailed(
+    workspace: str,
+    *,
+    client: Client,
+    page: Union[Unset, None, int] = UNSET,
+    per_page: Union[Unset, None, int] = UNSET,
+    order_desc: Union[Unset, None, bool] = UNSET,
+    created_by: Union[Unset, None, str] = UNSET,
+    path_start: Union[Unset, None, str] = UNSET,
+    path_exact: Union[Unset, None, str] = UNSET,
+    first_parent_hash: Union[Unset, None, str] = UNSET,
+    last_parent_hash: Union[Unset, None, str] = UNSET,
+    parent_hash: Union[Unset, None, str] = UNSET,
+    show_archived: Union[Unset, None, bool] = UNSET,
+    is_template: Union[Unset, None, bool] = UNSET,
+    kind: Union[Unset, None, str] = UNSET,
+) -> Response[List[ListScriptsResponse200Item]]:
+    """list all available scripts
+
+    Args:
+        workspace (str):
+        page (Union[Unset, None, int]):
+        per_page (Union[Unset, None, int]):
+        order_desc (Union[Unset, None, bool]):
+        created_by (Union[Unset, None, str]):
+        path_start (Union[Unset, None, str]):
+        path_exact (Union[Unset, None, str]):
+        first_parent_hash (Union[Unset, None, str]):
+        last_parent_hash (Union[Unset, None, str]):
+        parent_hash (Union[Unset, None, str]):
+        show_archived (Union[Unset, None, bool]):
+        is_template (Union[Unset, None, bool]):
+        kind (Union[Unset, None, str]):
+
+    Returns:
+        Response[List[ListScriptsResponse200Item]]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        client=client,
+        page=page,
+        per_page=per_page,
+        order_desc=order_desc,
+        created_by=created_by,
+        path_start=path_start,
+        path_exact=path_exact,
+        first_parent_hash=first_parent_hash,
+        last_parent_hash=last_parent_hash,
+        parent_hash=parent_hash,
+        show_archived=show_archived,
+        is_template=is_template,
+        kind=kind,
+    )
+
+    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,
+    page: Union[Unset, None, int] = UNSET,
+    per_page: Union[Unset, None, int] = UNSET,
+    order_desc: Union[Unset, None, bool] = UNSET,
+    created_by: Union[Unset, None, str] = UNSET,
+    path_start: Union[Unset, None, str] = UNSET,
+    path_exact: Union[Unset, None, str] = UNSET,
+    first_parent_hash: Union[Unset, None, str] = UNSET,
+    last_parent_hash: Union[Unset, None, str] = UNSET,
+    parent_hash: Union[Unset, None, str] = UNSET,
+    show_archived: Union[Unset, None, bool] = UNSET,
+    is_template: Union[Unset, None, bool] = UNSET,
+    kind: Union[Unset, None, str] = UNSET,
+) -> Optional[List[ListScriptsResponse200Item]]:
+    """list all available scripts
+
+    Args:
+        workspace (str):
+        page (Union[Unset, None, int]):
+        per_page (Union[Unset, None, int]):
+        order_desc (Union[Unset, None, bool]):
+        created_by (Union[Unset, None, str]):
+        path_start (Union[Unset, None, str]):
+        path_exact (Union[Unset, None, str]):
+        first_parent_hash (Union[Unset, None, str]):
+        last_parent_hash (Union[Unset, None, str]):
+        parent_hash (Union[Unset, None, str]):
+        show_archived (Union[Unset, None, bool]):
+        is_template (Union[Unset, None, bool]):
+        kind (Union[Unset, None, str]):
+
+    Returns:
+        Response[List[ListScriptsResponse200Item]]
+    """
+
+    return (
+        await asyncio_detailed(
+            workspace=workspace,
+            client=client,
+            page=page,
+            per_page=per_page,
+            order_desc=order_desc,
+            created_by=created_by,
+            path_start=path_start,
+            path_exact=path_exact,
+            first_parent_hash=first_parent_hash,
+            last_parent_hash=last_parent_hash,
+            parent_hash=parent_hash,
+            show_archived=show_archived,
+            is_template=is_template,
+            kind=kind,
+        )
+    ).parsed

python-client/windmill-api/windmill_api/api/script/python_to_jsonschema.py

@@ -0,0 +1,140 @@
+from typing import Any, Dict, Optional
+
+import httpx
+
+from ...client import Client
+from ...models.python_to_jsonschema_response_200 import PythonToJsonschemaResponse200
+from ...types import Response
+
+
+def _get_kwargs(
+    *,
+    client: Client,
+    json_body: str,
+) -> Dict[str, Any]:
+    url = "{}/scripts/python/tojsonschema".format(client.base_url)
+
+    headers: Dict[str, str] = client.get_headers()
+    cookies: Dict[str, Any] = client.get_cookies()
+
+    json_json_body = json_body
+
+    return {
+        "method": "post",
+        "url": url,
+        "headers": headers,
+        "cookies": cookies,
+        "timeout": client.get_timeout(),
+        "json": json_json_body,
+    }
+
+
+def _parse_response(*, response: httpx.Response) -> Optional[PythonToJsonschemaResponse200]:
+    if response.status_code == 200:
+        response_200 = PythonToJsonschemaResponse200.from_dict(response.json())
+
+        return response_200
+    return None
+
+
+def _build_response(*, response: httpx.Response) -> Response[PythonToJsonschemaResponse200]:
+    return Response(
+        status_code=response.status_code,
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: Client,
+    json_body: str,
+) -> Response[PythonToJsonschemaResponse200]:
+    """inspect python code to infer jsonschema of arguments
+
+    Args:
+        json_body (str):
+
+    Returns:
+        Response[PythonToJsonschemaResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        client=client,
+        json_body=json_body,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+def sync(
+    *,
+    client: Client,
+    json_body: str,
+) -> Optional[PythonToJsonschemaResponse200]:
+    """inspect python code to infer jsonschema of arguments
+
+    Args:
+        json_body (str):
+
+    Returns:
+        Response[PythonToJsonschemaResponse200]
+    """
+
+    return sync_detailed(
+        client=client,
+        json_body=json_body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: Client,
+    json_body: str,
+) -> Response[PythonToJsonschemaResponse200]:
+    """inspect python code to infer jsonschema of arguments
+
+    Args:
+        json_body (str):
+
+    Returns:
+        Response[PythonToJsonschemaResponse200]
+    """
+
+    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)
+
+
+async def asyncio(
+    *,
+    client: Client,
+    json_body: str,
+) -> Optional[PythonToJsonschemaResponse200]:
+    """inspect python code to infer jsonschema of arguments
+
+    Args:
+        json_body (str):
+
+    Returns:
+        Response[PythonToJsonschemaResponse200]
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+            json_body=json_body,
+        )
+    ).parsed

python-client/windmill-api/windmill_api/api/script/raw_script_by_hash.py

@@ -0,0 +1,93 @@
+from typing import Any, Dict
+
+import httpx
+
+from ...client import Client
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/scripts/raw/h/{path}".format(client.base_url, workspace=workspace, path=path)
+
+    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 _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,
+    path: str,
+    *,
+    client: Client,
+) -> Response[Any]:
+    """raw script by hash
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        client=client,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+async def asyncio_detailed(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Response[Any]:
+    """raw script by hash
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        client=client,
+    )
+
+    async with httpx.AsyncClient(verify=client.verify_ssl) as _client:
+        response = await _client.request(**kwargs)
+
+    return _build_response(response=response)

python-client/windmill-api/windmill_api/api/script/raw_script_by_path.py

@@ -0,0 +1,93 @@
+from typing import Any, Dict
+
+import httpx
+
+from ...client import Client
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Dict[str, Any]:
+    url = "{}/w/{workspace}/scripts/raw/p/{path}".format(client.base_url, workspace=workspace, path=path)
+
+    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 _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,
+    path: str,
+    *,
+    client: Client,
+) -> Response[Any]:
+    """raw script by path
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        client=client,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+async def asyncio_detailed(
+    workspace: str,
+    path: str,
+    *,
+    client: Client,
+) -> Response[Any]:
+    """raw script by path
+
+    Args:
+        workspace (str):
+        path (str):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        path=path,
+        client=client,
+    )
+
+    async with httpx.AsyncClient(verify=client.verify_ssl) as _client:
+        response = await _client.request(**kwargs)
+
+    return _build_response(response=response)

python-client/windmill-api/windmill_api/api/settings/backend_version.py

@@ -0,0 +1,75 @@
+from typing import Any, Dict
+
+import httpx
+
+from ...client import Client
+from ...types import Response
+
+
+def _get_kwargs(
+    *,
+    client: Client,
+) -> Dict[str, Any]:
+    url = "{}/version".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 _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,
+) -> Response[Any]:
+    """get backend version
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        client=client,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+async def asyncio_detailed(
+    *,
+    client: Client,
+) -> Response[Any]:
+    """get backend version
+
+    Returns:
+        Response[Any]
+    """
+
+    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)

python-client/windmill-api/windmill_api/api/settings/get_open_api_yaml.py

@@ -0,0 +1,75 @@
+from typing import Any, Dict
+
+import httpx
+
+from ...client import Client
+from ...types import Response
+
+
+def _get_kwargs(
+    *,
+    client: Client,
+) -> Dict[str, Any]:
+    url = "{}/openapi.yaml".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 _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,
+) -> Response[Any]:
+    """get openapi yaml spec
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        client=client,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+async def asyncio_detailed(
+    *,
+    client: Client,
+) -> Response[Any]:
+    """get openapi yaml spec
+
+    Returns:
+        Response[Any]
+    """
+
+    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)

python-client/windmill-api/windmill_api/api/user/accept_invite.py

@@ -0,0 +1,90 @@
+from typing import Any, Dict
+
+import httpx
+
+from ...client import Client
+from ...models.accept_invite_json_body import AcceptInviteJsonBody
+from ...types import Response
+
+
+def _get_kwargs(
+    *,
+    client: Client,
+    json_body: AcceptInviteJsonBody,
+) -> Dict[str, Any]:
+    url = "{}/users/accept_invite".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: AcceptInviteJsonBody,
+) -> Response[Any]:
+    """accept invite to workspace
+
+    Args:
+        json_body (AcceptInviteJsonBody):
+
+    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: AcceptInviteJsonBody,
+) -> Response[Any]:
+    """accept invite to workspace
+
+    Args:
+        json_body (AcceptInviteJsonBody):
+
+    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)

python-client/windmill-api/windmill_api/api/user/create_token.py

@@ -0,0 +1,90 @@
+from typing import Any, Dict
+
+import httpx
+
+from ...client import Client
+from ...models.create_token_json_body import CreateTokenJsonBody
+from ...types import Response
+
+
+def _get_kwargs(
+    *,
+    client: Client,
+    json_body: CreateTokenJsonBody,
+) -> Dict[str, Any]:
+    url = "{}/users/tokens/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: CreateTokenJsonBody,
+) -> Response[Any]:
+    """create token
+
+    Args:
+        json_body (CreateTokenJsonBody):
+
+    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: CreateTokenJsonBody,
+) -> Response[Any]:
+    """create token
+
+    Args:
+        json_body (CreateTokenJsonBody):
+
+    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)