windmill-client 0.1.0

package/src/services/UserService.ts

@@ -0,0 +1,574 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { EditWorkspaceUser } from '../models/EditWorkspaceUser';
+import type { GlobalUserInfo } from '../models/GlobalUserInfo';
+import type { Login } from '../models/Login';
+import type { NewToken } from '../models/NewToken';
+import type { NewTokenImpersonate } from '../models/NewTokenImpersonate';
+import type { NewUser } from '../models/NewUser';
+import type { TruncatedToken } from '../models/TruncatedToken';
+import type { User } from '../models/User';
+import type { WorkspaceInvite } from '../models/WorkspaceInvite';
+
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+
+export class UserService {
+
+    /**
+     * login with password
+     * @returns string Successfully authenticated. The session ID is returned in a cookie named `token` and as plaintext response. Preferred method of authorization is through the bearer token. The cookie is only for browser convenience.
+     *
+     * @throws ApiError
+     */
+    public static login({
+        requestBody,
+    }: {
+        /**
+         * credentials
+         */
+        requestBody: Login,
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/auth/login',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+
+    /**
+     * logout
+     * @returns string clear cookies and clear token (if applicable)
+     * @throws ApiError
+     */
+    public static logout(): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/auth/logout',
+        });
+    }
+
+    /**
+     * create user (require admin privilege)
+     * @returns string user created
+     * @throws ApiError
+     */
+    public static createUser({
+        workspace,
+        requestBody,
+    }: {
+        workspace: string,
+        /**
+         * new user
+         */
+        requestBody: NewUser,
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/users/add',
+            path: {
+                'workspace': workspace,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+
+    /**
+     * update user (require admin privilege)
+     * @returns string edited user
+     * @throws ApiError
+     */
+    public static updateUser({
+        workspace,
+        username,
+        requestBody,
+    }: {
+        workspace: string,
+        username: string,
+        /**
+         * new user
+         */
+        requestBody: EditWorkspaceUser,
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/users/update/{username}',
+            path: {
+                'workspace': workspace,
+                'username': username,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+
+    /**
+     * is owner of path
+     * @returns boolean is owner
+     * @throws ApiError
+     */
+    public static isOwnerOfPath({
+        workspace,
+        path,
+    }: {
+        workspace: string,
+        path: string,
+    }): CancelablePromise<boolean> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/users/is_owner/{path}',
+            path: {
+                'workspace': workspace,
+                'path': path,
+            },
+        });
+    }
+
+    /**
+     * set password
+     * @returns string password set
+     * @throws ApiError
+     */
+    public static setPassword({
+        requestBody,
+    }: {
+        /**
+         * set password
+         */
+        requestBody: {
+            password: string;
+        },
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/users/setpassword',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+
+    /**
+     * create user
+     * @returns string user created
+     * @throws ApiError
+     */
+    public static createUserGlobally({
+        requestBody,
+    }: {
+        /**
+         * user info
+         */
+        requestBody: {
+            email: string;
+            password: string;
+            super_admin: boolean;
+            name?: string;
+            company?: string;
+        },
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/users/create',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+
+    /**
+     * global update user (require super admin)
+     * @returns string user updated
+     * @throws ApiError
+     */
+    public static globalUserUpdate({
+        email,
+        requestBody,
+    }: {
+        email: string,
+        /**
+         * new user info
+         */
+        requestBody: {
+            is_super_admin?: boolean;
+        },
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/users/update/{email}',
+            path: {
+                'email': email,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+
+    /**
+     * global delete user (require super admin)
+     * @returns string user deleted
+     * @throws ApiError
+     */
+    public static globalUserDelete({
+        email,
+    }: {
+        email: string,
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/users/delete/{email}',
+            path: {
+                'email': email,
+            },
+        });
+    }
+
+    /**
+     * delete user (require admin privilege)
+     * @returns string delete user
+     * @throws ApiError
+     */
+    public static deleteUser({
+        workspace,
+        username,
+    }: {
+        workspace: string,
+        username: string,
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/w/{workspace}/users/delete/{username}',
+            path: {
+                'workspace': workspace,
+                'username': username,
+            },
+        });
+    }
+
+    /**
+     * get current user email (if logged in)
+     * @returns string user email
+     * @throws ApiError
+     */
+    public static getCurrentEmail(): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/users/email',
+        });
+    }
+
+    /**
+     * get current usage outside of premium workspaces
+     * @returns number free usage
+     * @throws ApiError
+     */
+    public static getUsage(): CancelablePromise<number> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/users/usage',
+        });
+    }
+
+    /**
+     * get current global whoami (if logged in)
+     * @returns GlobalUserInfo user email
+     * @throws ApiError
+     */
+    public static globalWhoami(): CancelablePromise<GlobalUserInfo> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/users/whoami',
+        });
+    }
+
+    /**
+     * list all workspace invites
+     * @returns WorkspaceInvite list all workspace invites
+     * @throws ApiError
+     */
+    public static listWorkspaceInvites(): CancelablePromise<Array<WorkspaceInvite>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/users/list_invites',
+        });
+    }
+
+    /**
+     * whoami
+     * @returns User user
+     * @throws ApiError
+     */
+    public static whoami({
+        workspace,
+    }: {
+        workspace: string,
+    }): CancelablePromise<User> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/users/whoami',
+            path: {
+                'workspace': workspace,
+            },
+        });
+    }
+
+    /**
+     * leave workspace
+     * @returns string status
+     * @throws ApiError
+     */
+    public static leaveWorkspace({
+        workspace,
+    }: {
+        workspace: string,
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/users/leave_workspace',
+            path: {
+                'workspace': workspace,
+            },
+        });
+    }
+
+    /**
+     * accept invite to workspace
+     * @returns string status
+     * @throws ApiError
+     */
+    public static acceptInvite({
+        requestBody,
+    }: {
+        /**
+         * accept invite
+         */
+        requestBody: {
+            workspace_id: string;
+            username: string;
+        },
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/users/accept_invite',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+
+    /**
+     * decline invite to workspace
+     * @returns string status
+     * @throws ApiError
+     */
+    public static declineInvite({
+        requestBody,
+    }: {
+        /**
+         * decline invite
+         */
+        requestBody: {
+            workspace_id: string;
+        },
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/users/decline_invite',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+
+    /**
+     * whois
+     * @returns User user
+     * @throws ApiError
+     */
+    public static whois({
+        workspace,
+        username,
+    }: {
+        workspace: string,
+        username: string,
+    }): CancelablePromise<User> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/users/whois/{username}',
+            path: {
+                'workspace': workspace,
+                'username': username,
+            },
+        });
+    }
+
+    /**
+     * list all users as super admin (require to be super amdin)
+     * @returns GlobalUserInfo user
+     * @throws ApiError
+     */
+    public static listUsersAsSuperAdmin({
+        page,
+        perPage,
+    }: {
+        /**
+         * which page to return (start at 1, default 1)
+         */
+        page?: number,
+        /**
+         * number of items to return for a given page (default 30, max 100)
+         */
+        perPage?: number,
+    }): CancelablePromise<Array<GlobalUserInfo>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/users/list_as_super_admin',
+            query: {
+                'page': page,
+                'per_page': perPage,
+            },
+        });
+    }
+
+    /**
+     * list users
+     * @returns User user
+     * @throws ApiError
+     */
+    public static listUsers({
+        workspace,
+    }: {
+        workspace: string,
+    }): CancelablePromise<Array<User>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/users/list',
+            path: {
+                'workspace': workspace,
+            },
+        });
+    }
+
+    /**
+     * list usernames
+     * @returns string user
+     * @throws ApiError
+     */
+    public static listUsernames({
+        workspace,
+    }: {
+        workspace: string,
+    }): CancelablePromise<Array<string>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/users/list_usernames',
+            path: {
+                'workspace': workspace,
+            },
+        });
+    }
+
+    /**
+     * create token
+     * @returns string token created
+     * @throws ApiError
+     */
+    public static createToken({
+        requestBody,
+    }: {
+        /**
+         * new token
+         */
+        requestBody: NewToken,
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/users/tokens/create',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+
+    /**
+     * create token to impersonate a user (require superadmin)
+     * @returns string token created
+     * @throws ApiError
+     */
+    public static createTokenImpersonate({
+        requestBody,
+    }: {
+        /**
+         * new token
+         */
+        requestBody: NewTokenImpersonate,
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/users/tokens/impersonate',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+
+    /**
+     * delete token
+     * @returns string delete token
+     * @throws ApiError
+     */
+    public static deleteToken({
+        tokenPrefix,
+    }: {
+        tokenPrefix: string,
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/users/tokens/delete/{token_prefix}',
+            path: {
+                'token_prefix': tokenPrefix,
+            },
+        });
+    }
+
+    /**
+     * list token
+     * @returns TruncatedToken truncated token
+     * @throws ApiError
+     */
+    public static listTokens(): CancelablePromise<Array<TruncatedToken>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/users/tokens/list',
+        });
+    }
+
+    /**
+     * login with oauth authorization flow
+     * @returns string Successfully authenticated. The session ID is returned in a cookie named `token` and as plaintext response. Preferred method of authorization is through the bearer token. The cookie is only for browser convenience.
+     *
+     * @throws ApiError
+     */
+    public static loginWithOauth({
+        clientName,
+        requestBody,
+    }: {
+        clientName: string,
+        /**
+         * Partially filled script
+         */
+        requestBody: {
+            code?: string;
+            state?: string;
+        },
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/oauth/login_callback/{client_name}',
+            path: {
+                'client_name': clientName,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+
+}