123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519
/* istanbul ignore file *//* tslint:disable *//* eslint-disable */import type { EditWorkspaceUser } from '../models/EditWorkspaceUser.ts';import type { GlobalUserInfo } from '../models/GlobalUserInfo.ts';import type { Login } from '../models/Login.ts';import type { NewToken } from '../models/NewToken.ts';import type { NewUser } from '../models/NewUser.ts';import type { TruncatedToken } from '../models/TruncatedToken.ts';import type { User } from '../models/User.ts';import type { WorkspaceInvite } from '../models/WorkspaceInvite.ts';
import type { CancelablePromise } from '../core/CancelablePromise.ts';import { OpenAPI } from '../core/OpenAPI.ts';import { request as __request } from '../core/request.ts';
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',        });    }
    /**     * 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 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',        });    }
    /**     * 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',        });    }
}