@appwrite.io/console 0.0.1

package/src/services/users.ts

@@ -0,0 +1,1020 @@
+import { Service } from '../service';
+import { AppwriteException, Client } from '../client';
+import type { Models } from '../models';
+import type { UploadProgress, Payload } from '../client';
+
+export class Users extends Service {
+
+     constructor(client: Client)
+     {
+        super(client);
+     }
+
+        /**
+         * List Users
+         *
+         * Get a list of all the project's users. You can use the query params to
+         * filter your results.
+         *
+         * @param {string[]} queries
+         * @param {string} search
+         * @throws {AppwriteException}
+         * @returns {Promise}
+         */
+        async list<Preferences extends Models.Preferences>(queries?: string[], search?: string): Promise<Models.UserList<Preferences>> {
+            let path = '/users';
+            let payload: Payload = {};
+
+            if (typeof queries !== 'undefined') {
+                payload['queries'] = queries;
+            }
+
+            if (typeof search !== 'undefined') {
+                payload['search'] = search;
+            }
+
+            const uri = new URL(this.client.config.endpoint + path);
+            return await this.client.call('get', uri, {
+                'content-type': 'application/json',
+            }, payload);
+        }
+
+        /**
+         * Create User
+         *
+         * Create a new user.
+         *
+         * @param {string} userId
+         * @param {string} email
+         * @param {string} phone
+         * @param {string} password
+         * @param {string} name
+         * @throws {AppwriteException}
+         * @returns {Promise}
+         */
+        async create<Preferences extends Models.Preferences>(userId: string, email?: string, phone?: string, password?: string, name?: string): Promise<Models.User<Preferences>> {
+            if (typeof userId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "userId"');
+            }
+
+            let path = '/users';
+            let payload: Payload = {};
+
+            if (typeof userId !== 'undefined') {
+                payload['userId'] = userId;
+            }
+
+            if (typeof email !== 'undefined') {
+                payload['email'] = email;
+            }
+
+            if (typeof phone !== 'undefined') {
+                payload['phone'] = phone;
+            }
+
+            if (typeof password !== 'undefined') {
+                payload['password'] = password;
+            }
+
+            if (typeof name !== 'undefined') {
+                payload['name'] = name;
+            }
+
+            const uri = new URL(this.client.config.endpoint + path);
+            return await this.client.call('post', uri, {
+                'content-type': 'application/json',
+            }, payload);
+        }
+
+        /**
+         * Create User with Argon2 Password
+         *
+         * Create a new user. Password provided must be hashed with the
+         * [Argon2](https://en.wikipedia.org/wiki/Argon2) algorithm. Use the [POST
+         * /users](/docs/server/users#usersCreate) endpoint to create users with a
+         * plain text password.
+         *
+         * @param {string} userId
+         * @param {string} email
+         * @param {string} password
+         * @param {string} name
+         * @throws {AppwriteException}
+         * @returns {Promise}
+         */
+        async createArgon2User<Preferences extends Models.Preferences>(userId: string, email: string, password: string, name?: string): Promise<Models.User<Preferences>> {
+            if (typeof userId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "userId"');
+            }
+
+            if (typeof email === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "email"');
+            }
+
+            if (typeof password === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "password"');
+            }
+
+            let path = '/users/argon2';
+            let payload: Payload = {};
+
+            if (typeof userId !== 'undefined') {
+                payload['userId'] = userId;
+            }
+
+            if (typeof email !== 'undefined') {
+                payload['email'] = email;
+            }
+
+            if (typeof password !== 'undefined') {
+                payload['password'] = password;
+            }
+
+            if (typeof name !== 'undefined') {
+                payload['name'] = name;
+            }
+
+            const uri = new URL(this.client.config.endpoint + path);
+            return await this.client.call('post', uri, {
+                'content-type': 'application/json',
+            }, payload);
+        }
+
+        /**
+         * Create User with Bcrypt Password
+         *
+         * Create a new user. Password provided must be hashed with the
+         * [Bcrypt](https://en.wikipedia.org/wiki/Bcrypt) algorithm. Use the [POST
+         * /users](/docs/server/users#usersCreate) endpoint to create users with a
+         * plain text password.
+         *
+         * @param {string} userId
+         * @param {string} email
+         * @param {string} password
+         * @param {string} name
+         * @throws {AppwriteException}
+         * @returns {Promise}
+         */
+        async createBcryptUser<Preferences extends Models.Preferences>(userId: string, email: string, password: string, name?: string): Promise<Models.User<Preferences>> {
+            if (typeof userId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "userId"');
+            }
+
+            if (typeof email === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "email"');
+            }
+
+            if (typeof password === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "password"');
+            }
+
+            let path = '/users/bcrypt';
+            let payload: Payload = {};
+
+            if (typeof userId !== 'undefined') {
+                payload['userId'] = userId;
+            }
+
+            if (typeof email !== 'undefined') {
+                payload['email'] = email;
+            }
+
+            if (typeof password !== 'undefined') {
+                payload['password'] = password;
+            }
+
+            if (typeof name !== 'undefined') {
+                payload['name'] = name;
+            }
+
+            const uri = new URL(this.client.config.endpoint + path);
+            return await this.client.call('post', uri, {
+                'content-type': 'application/json',
+            }, payload);
+        }
+
+        /**
+         * Create User with MD5 Password
+         *
+         * Create a new user. Password provided must be hashed with the
+         * [MD5](https://en.wikipedia.org/wiki/MD5) algorithm. Use the [POST
+         * /users](/docs/server/users#usersCreate) endpoint to create users with a
+         * plain text password.
+         *
+         * @param {string} userId
+         * @param {string} email
+         * @param {string} password
+         * @param {string} name
+         * @throws {AppwriteException}
+         * @returns {Promise}
+         */
+        async createMD5User<Preferences extends Models.Preferences>(userId: string, email: string, password: string, name?: string): Promise<Models.User<Preferences>> {
+            if (typeof userId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "userId"');
+            }
+
+            if (typeof email === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "email"');
+            }
+
+            if (typeof password === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "password"');
+            }
+
+            let path = '/users/md5';
+            let payload: Payload = {};
+
+            if (typeof userId !== 'undefined') {
+                payload['userId'] = userId;
+            }
+
+            if (typeof email !== 'undefined') {
+                payload['email'] = email;
+            }
+
+            if (typeof password !== 'undefined') {
+                payload['password'] = password;
+            }
+
+            if (typeof name !== 'undefined') {
+                payload['name'] = name;
+            }
+
+            const uri = new URL(this.client.config.endpoint + path);
+            return await this.client.call('post', uri, {
+                'content-type': 'application/json',
+            }, payload);
+        }
+
+        /**
+         * Create User with PHPass Password
+         *
+         * Create a new user. Password provided must be hashed with the
+         * [PHPass](https://www.openwall.com/phpass/) algorithm. Use the [POST
+         * /users](/docs/server/users#usersCreate) endpoint to create users with a
+         * plain text password.
+         *
+         * @param {string} userId
+         * @param {string} email
+         * @param {string} password
+         * @param {string} name
+         * @throws {AppwriteException}
+         * @returns {Promise}
+         */
+        async createPHPassUser<Preferences extends Models.Preferences>(userId: string, email: string, password: string, name?: string): Promise<Models.User<Preferences>> {
+            if (typeof userId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "userId"');
+            }
+
+            if (typeof email === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "email"');
+            }
+
+            if (typeof password === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "password"');
+            }
+
+            let path = '/users/phpass';
+            let payload: Payload = {};
+
+            if (typeof userId !== 'undefined') {
+                payload['userId'] = userId;
+            }
+
+            if (typeof email !== 'undefined') {
+                payload['email'] = email;
+            }
+
+            if (typeof password !== 'undefined') {
+                payload['password'] = password;
+            }
+
+            if (typeof name !== 'undefined') {
+                payload['name'] = name;
+            }
+
+            const uri = new URL(this.client.config.endpoint + path);
+            return await this.client.call('post', uri, {
+                'content-type': 'application/json',
+            }, payload);
+        }
+
+        /**
+         * Create User with Scrypt Password
+         *
+         * Create a new user. Password provided must be hashed with the
+         * [Scrypt](https://github.com/Tarsnap/scrypt) algorithm. Use the [POST
+         * /users](/docs/server/users#usersCreate) endpoint to create users with a
+         * plain text password.
+         *
+         * @param {string} userId
+         * @param {string} email
+         * @param {string} password
+         * @param {string} passwordSalt
+         * @param {number} passwordCpu
+         * @param {number} passwordMemory
+         * @param {number} passwordParallel
+         * @param {number} passwordLength
+         * @param {string} name
+         * @throws {AppwriteException}
+         * @returns {Promise}
+         */
+        async createScryptUser<Preferences extends Models.Preferences>(userId: string, email: string, password: string, passwordSalt: string, passwordCpu: number, passwordMemory: number, passwordParallel: number, passwordLength: number, name?: string): Promise<Models.User<Preferences>> {
+            if (typeof userId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "userId"');
+            }
+
+            if (typeof email === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "email"');
+            }
+
+            if (typeof password === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "password"');
+            }
+
+            if (typeof passwordSalt === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "passwordSalt"');
+            }
+
+            if (typeof passwordCpu === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "passwordCpu"');
+            }
+
+            if (typeof passwordMemory === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "passwordMemory"');
+            }
+
+            if (typeof passwordParallel === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "passwordParallel"');
+            }
+
+            if (typeof passwordLength === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "passwordLength"');
+            }
+
+            let path = '/users/scrypt';
+            let payload: Payload = {};
+
+            if (typeof userId !== 'undefined') {
+                payload['userId'] = userId;
+            }
+
+            if (typeof email !== 'undefined') {
+                payload['email'] = email;
+            }
+
+            if (typeof password !== 'undefined') {
+                payload['password'] = password;
+            }
+
+            if (typeof passwordSalt !== 'undefined') {
+                payload['passwordSalt'] = passwordSalt;
+            }
+
+            if (typeof passwordCpu !== 'undefined') {
+                payload['passwordCpu'] = passwordCpu;
+            }
+
+            if (typeof passwordMemory !== 'undefined') {
+                payload['passwordMemory'] = passwordMemory;
+            }
+
+            if (typeof passwordParallel !== 'undefined') {
+                payload['passwordParallel'] = passwordParallel;
+            }
+
+            if (typeof passwordLength !== 'undefined') {
+                payload['passwordLength'] = passwordLength;
+            }
+
+            if (typeof name !== 'undefined') {
+                payload['name'] = name;
+            }
+
+            const uri = new URL(this.client.config.endpoint + path);
+            return await this.client.call('post', uri, {
+                'content-type': 'application/json',
+            }, payload);
+        }
+
+        /**
+         * Create User with Scrypt Modified Password
+         *
+         * Create a new user. Password provided must be hashed with the [Scrypt
+         * Modified](https://gist.github.com/Meldiron/eecf84a0225eccb5a378d45bb27462cc)
+         * algorithm. Use the [POST /users](/docs/server/users#usersCreate) endpoint
+         * to create users with a plain text password.
+         *
+         * @param {string} userId
+         * @param {string} email
+         * @param {string} password
+         * @param {string} passwordSalt
+         * @param {string} passwordSaltSeparator
+         * @param {string} passwordSignerKey
+         * @param {string} name
+         * @throws {AppwriteException}
+         * @returns {Promise}
+         */
+        async createScryptModifiedUser<Preferences extends Models.Preferences>(userId: string, email: string, password: string, passwordSalt: string, passwordSaltSeparator: string, passwordSignerKey: string, name?: string): Promise<Models.User<Preferences>> {
+            if (typeof userId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "userId"');
+            }
+
+            if (typeof email === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "email"');
+            }
+
+            if (typeof password === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "password"');
+            }
+
+            if (typeof passwordSalt === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "passwordSalt"');
+            }
+
+            if (typeof passwordSaltSeparator === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "passwordSaltSeparator"');
+            }
+
+            if (typeof passwordSignerKey === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "passwordSignerKey"');
+            }
+
+            let path = '/users/scrypt-modified';
+            let payload: Payload = {};
+
+            if (typeof userId !== 'undefined') {
+                payload['userId'] = userId;
+            }
+
+            if (typeof email !== 'undefined') {
+                payload['email'] = email;
+            }
+
+            if (typeof password !== 'undefined') {
+                payload['password'] = password;
+            }
+
+            if (typeof passwordSalt !== 'undefined') {
+                payload['passwordSalt'] = passwordSalt;
+            }
+
+            if (typeof passwordSaltSeparator !== 'undefined') {
+                payload['passwordSaltSeparator'] = passwordSaltSeparator;
+            }
+
+            if (typeof passwordSignerKey !== 'undefined') {
+                payload['passwordSignerKey'] = passwordSignerKey;
+            }
+
+            if (typeof name !== 'undefined') {
+                payload['name'] = name;
+            }
+
+            const uri = new URL(this.client.config.endpoint + path);
+            return await this.client.call('post', uri, {
+                'content-type': 'application/json',
+            }, payload);
+        }
+
+        /**
+         * Create User with SHA Password
+         *
+         * Create a new user. Password provided must be hashed with the
+         * [SHA](https://en.wikipedia.org/wiki/Secure_Hash_Algorithm) algorithm. Use
+         * the [POST /users](/docs/server/users#usersCreate) endpoint to create users
+         * with a plain text password.
+         *
+         * @param {string} userId
+         * @param {string} email
+         * @param {string} password
+         * @param {string} passwordVersion
+         * @param {string} name
+         * @throws {AppwriteException}
+         * @returns {Promise}
+         */
+        async createSHAUser<Preferences extends Models.Preferences>(userId: string, email: string, password: string, passwordVersion?: string, name?: string): Promise<Models.User<Preferences>> {
+            if (typeof userId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "userId"');
+            }
+
+            if (typeof email === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "email"');
+            }
+
+            if (typeof password === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "password"');
+            }
+
+            let path = '/users/sha';
+            let payload: Payload = {};
+
+            if (typeof userId !== 'undefined') {
+                payload['userId'] = userId;
+            }
+
+            if (typeof email !== 'undefined') {
+                payload['email'] = email;
+            }
+
+            if (typeof password !== 'undefined') {
+                payload['password'] = password;
+            }
+
+            if (typeof passwordVersion !== 'undefined') {
+                payload['passwordVersion'] = passwordVersion;
+            }
+
+            if (typeof name !== 'undefined') {
+                payload['name'] = name;
+            }
+
+            const uri = new URL(this.client.config.endpoint + path);
+            return await this.client.call('post', uri, {
+                'content-type': 'application/json',
+            }, payload);
+        }
+
+        /**
+         * Get usage stats for the users API
+         *
+         *
+         * @param {string} range
+         * @param {string} provider
+         * @throws {AppwriteException}
+         * @returns {Promise}
+         */
+        async getUsage(range?: string, provider?: string): Promise<Models.UsageUsers> {
+            let path = '/users/usage';
+            let payload: Payload = {};
+
+            if (typeof range !== 'undefined') {
+                payload['range'] = range;
+            }
+
+            if (typeof provider !== 'undefined') {
+                payload['provider'] = provider;
+            }
+
+            const uri = new URL(this.client.config.endpoint + path);
+            return await this.client.call('get', uri, {
+                'content-type': 'application/json',
+            }, payload);
+        }
+
+        /**
+         * Get User
+         *
+         * Get a user by its unique ID.
+         *
+         * @param {string} userId
+         * @throws {AppwriteException}
+         * @returns {Promise}
+         */
+        async get<Preferences extends Models.Preferences>(userId: string): Promise<Models.User<Preferences>> {
+            if (typeof userId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "userId"');
+            }
+
+            let path = '/users/{userId}'.replace('{userId}', userId);
+            let payload: Payload = {};
+
+            const uri = new URL(this.client.config.endpoint + path);
+            return await this.client.call('get', uri, {
+                'content-type': 'application/json',
+            }, payload);
+        }
+
+        /**
+         * Delete User
+         *
+         * Delete a user by its unique ID, thereby releasing it's ID. Since ID is
+         * released and can be reused, all user-related resources like documents or
+         * storage files should be deleted before user deletion. If you want to keep
+         * ID reserved, use the [updateStatus](/docs/server/users#usersUpdateStatus)
+         * endpoint instead.
+         *
+         * @param {string} userId
+         * @throws {AppwriteException}
+         * @returns {Promise}
+         */
+        async delete(userId: string): Promise<{}> {
+            if (typeof userId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "userId"');
+            }
+
+            let path = '/users/{userId}'.replace('{userId}', userId);
+            let payload: Payload = {};
+
+            const uri = new URL(this.client.config.endpoint + path);
+            return await this.client.call('delete', uri, {
+                'content-type': 'application/json',
+            }, payload);
+        }
+
+        /**
+         * Update Email
+         *
+         * Update the user email by its unique ID.
+         *
+         * @param {string} userId
+         * @param {string} email
+         * @throws {AppwriteException}
+         * @returns {Promise}
+         */
+        async updateEmail<Preferences extends Models.Preferences>(userId: string, email: string): Promise<Models.User<Preferences>> {
+            if (typeof userId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "userId"');
+            }
+
+            if (typeof email === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "email"');
+            }
+
+            let path = '/users/{userId}/email'.replace('{userId}', userId);
+            let payload: Payload = {};
+
+            if (typeof email !== 'undefined') {
+                payload['email'] = email;
+            }
+
+            const uri = new URL(this.client.config.endpoint + path);
+            return await this.client.call('patch', uri, {
+                'content-type': 'application/json',
+            }, payload);
+        }
+
+        /**
+         * List User Logs
+         *
+         * Get the user activity logs list by its unique ID.
+         *
+         * @param {string} userId
+         * @param {string[]} queries
+         * @throws {AppwriteException}
+         * @returns {Promise}
+         */
+        async listLogs(userId: string, queries?: string[]): Promise<Models.LogList> {
+            if (typeof userId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "userId"');
+            }
+
+            let path = '/users/{userId}/logs'.replace('{userId}', userId);
+            let payload: Payload = {};
+
+            if (typeof queries !== 'undefined') {
+                payload['queries'] = queries;
+            }
+
+            const uri = new URL(this.client.config.endpoint + path);
+            return await this.client.call('get', uri, {
+                'content-type': 'application/json',
+            }, payload);
+        }
+
+        /**
+         * List User Memberships
+         *
+         * Get the user membership list by its unique ID.
+         *
+         * @param {string} userId
+         * @throws {AppwriteException}
+         * @returns {Promise}
+         */
+        async listMemberships(userId: string): Promise<Models.MembershipList> {
+            if (typeof userId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "userId"');
+            }
+
+            let path = '/users/{userId}/memberships'.replace('{userId}', userId);
+            let payload: Payload = {};
+
+            const uri = new URL(this.client.config.endpoint + path);
+            return await this.client.call('get', uri, {
+                'content-type': 'application/json',
+            }, payload);
+        }
+
+        /**
+         * Update Name
+         *
+         * Update the user name by its unique ID.
+         *
+         * @param {string} userId
+         * @param {string} name
+         * @throws {AppwriteException}
+         * @returns {Promise}
+         */
+        async updateName<Preferences extends Models.Preferences>(userId: string, name: string): Promise<Models.User<Preferences>> {
+            if (typeof userId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "userId"');
+            }
+
+            if (typeof name === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "name"');
+            }
+
+            let path = '/users/{userId}/name'.replace('{userId}', userId);
+            let payload: Payload = {};
+
+            if (typeof name !== 'undefined') {
+                payload['name'] = name;
+            }
+
+            const uri = new URL(this.client.config.endpoint + path);
+            return await this.client.call('patch', uri, {
+                'content-type': 'application/json',
+            }, payload);
+        }
+
+        /**
+         * Update Password
+         *
+         * Update the user password by its unique ID.
+         *
+         * @param {string} userId
+         * @param {string} password
+         * @throws {AppwriteException}
+         * @returns {Promise}
+         */
+        async updatePassword<Preferences extends Models.Preferences>(userId: string, password: string): Promise<Models.User<Preferences>> {
+            if (typeof userId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "userId"');
+            }
+
+            if (typeof password === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "password"');
+            }
+
+            let path = '/users/{userId}/password'.replace('{userId}', userId);
+            let payload: Payload = {};
+
+            if (typeof password !== 'undefined') {
+                payload['password'] = password;
+            }
+
+            const uri = new URL(this.client.config.endpoint + path);
+            return await this.client.call('patch', uri, {
+                'content-type': 'application/json',
+            }, payload);
+        }
+
+        /**
+         * Update Phone
+         *
+         * Update the user phone by its unique ID.
+         *
+         * @param {string} userId
+         * @param {string} number
+         * @throws {AppwriteException}
+         * @returns {Promise}
+         */
+        async updatePhone<Preferences extends Models.Preferences>(userId: string, number: string): Promise<Models.User<Preferences>> {
+            if (typeof userId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "userId"');
+            }
+
+            if (typeof number === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "number"');
+            }
+
+            let path = '/users/{userId}/phone'.replace('{userId}', userId);
+            let payload: Payload = {};
+
+            if (typeof number !== 'undefined') {
+                payload['number'] = number;
+            }
+
+            const uri = new URL(this.client.config.endpoint + path);
+            return await this.client.call('patch', uri, {
+                'content-type': 'application/json',
+            }, payload);
+        }
+
+        /**
+         * Get User Preferences
+         *
+         * Get the user preferences by its unique ID.
+         *
+         * @param {string} userId
+         * @throws {AppwriteException}
+         * @returns {Promise}
+         */
+        async getPrefs<Preferences extends Models.Preferences>(userId: string): Promise<Preferences> {
+            if (typeof userId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "userId"');
+            }
+
+            let path = '/users/{userId}/prefs'.replace('{userId}', userId);
+            let payload: Payload = {};
+
+            const uri = new URL(this.client.config.endpoint + path);
+            return await this.client.call('get', uri, {
+                'content-type': 'application/json',
+            }, payload);
+        }
+
+        /**
+         * Update User Preferences
+         *
+         * Update the user preferences by its unique ID. The object you pass is stored
+         * as is, and replaces any previous value. The maximum allowed prefs size is
+         * 64kB and throws error if exceeded.
+         *
+         * @param {string} userId
+         * @param {object} prefs
+         * @throws {AppwriteException}
+         * @returns {Promise}
+         */
+        async updatePrefs<Preferences extends Models.Preferences>(userId: string, prefs: object): Promise<Preferences> {
+            if (typeof userId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "userId"');
+            }
+
+            if (typeof prefs === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "prefs"');
+            }
+
+            let path = '/users/{userId}/prefs'.replace('{userId}', userId);
+            let payload: Payload = {};
+
+            if (typeof prefs !== 'undefined') {
+                payload['prefs'] = prefs;
+            }
+
+            const uri = new URL(this.client.config.endpoint + path);
+            return await this.client.call('patch', uri, {
+                'content-type': 'application/json',
+            }, payload);
+        }
+
+        /**
+         * List User Sessions
+         *
+         * Get the user sessions list by its unique ID.
+         *
+         * @param {string} userId
+         * @throws {AppwriteException}
+         * @returns {Promise}
+         */
+        async listSessions(userId: string): Promise<Models.SessionList> {
+            if (typeof userId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "userId"');
+            }
+
+            let path = '/users/{userId}/sessions'.replace('{userId}', userId);
+            let payload: Payload = {};
+
+            const uri = new URL(this.client.config.endpoint + path);
+            return await this.client.call('get', uri, {
+                'content-type': 'application/json',
+            }, payload);
+        }
+
+        /**
+         * Delete User Sessions
+         *
+         * Delete all user's sessions by using the user's unique ID.
+         *
+         * @param {string} userId
+         * @throws {AppwriteException}
+         * @returns {Promise}
+         */
+        async deleteSessions(userId: string): Promise<{}> {
+            if (typeof userId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "userId"');
+            }
+
+            let path = '/users/{userId}/sessions'.replace('{userId}', userId);
+            let payload: Payload = {};
+
+            const uri = new URL(this.client.config.endpoint + path);
+            return await this.client.call('delete', uri, {
+                'content-type': 'application/json',
+            }, payload);
+        }
+
+        /**
+         * Delete User Session
+         *
+         * Delete a user sessions by its unique ID.
+         *
+         * @param {string} userId
+         * @param {string} sessionId
+         * @throws {AppwriteException}
+         * @returns {Promise}
+         */
+        async deleteSession(userId: string, sessionId: string): Promise<{}> {
+            if (typeof userId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "userId"');
+            }
+
+            if (typeof sessionId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "sessionId"');
+            }
+
+            let path = '/users/{userId}/sessions/{sessionId}'.replace('{userId}', userId).replace('{sessionId}', sessionId);
+            let payload: Payload = {};
+
+            const uri = new URL(this.client.config.endpoint + path);
+            return await this.client.call('delete', uri, {
+                'content-type': 'application/json',
+            }, payload);
+        }
+
+        /**
+         * Update User Status
+         *
+         * Update the user status by its unique ID. Use this endpoint as an
+         * alternative to deleting a user if you want to keep user's ID reserved.
+         *
+         * @param {string} userId
+         * @param {boolean} status
+         * @throws {AppwriteException}
+         * @returns {Promise}
+         */
+        async updateStatus<Preferences extends Models.Preferences>(userId: string, status: boolean): Promise<Models.User<Preferences>> {
+            if (typeof userId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "userId"');
+            }
+
+            if (typeof status === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "status"');
+            }
+
+            let path = '/users/{userId}/status'.replace('{userId}', userId);
+            let payload: Payload = {};
+
+            if (typeof status !== 'undefined') {
+                payload['status'] = status;
+            }
+
+            const uri = new URL(this.client.config.endpoint + path);
+            return await this.client.call('patch', uri, {
+                'content-type': 'application/json',
+            }, payload);
+        }
+
+        /**
+         * Update Email Verification
+         *
+         * Update the user email verification status by its unique ID.
+         *
+         * @param {string} userId
+         * @param {boolean} emailVerification
+         * @throws {AppwriteException}
+         * @returns {Promise}
+         */
+        async updateEmailVerification<Preferences extends Models.Preferences>(userId: string, emailVerification: boolean): Promise<Models.User<Preferences>> {
+            if (typeof userId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "userId"');
+            }
+
+            if (typeof emailVerification === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "emailVerification"');
+            }
+
+            let path = '/users/{userId}/verification'.replace('{userId}', userId);
+            let payload: Payload = {};
+
+            if (typeof emailVerification !== 'undefined') {
+                payload['emailVerification'] = emailVerification;
+            }
+
+            const uri = new URL(this.client.config.endpoint + path);
+            return await this.client.call('patch', uri, {
+                'content-type': 'application/json',
+            }, payload);
+        }
+
+        /**
+         * Update Phone Verification
+         *
+         * Update the user phone verification status by its unique ID.
+         *
+         * @param {string} userId
+         * @param {boolean} phoneVerification
+         * @throws {AppwriteException}
+         * @returns {Promise}
+         */
+        async updatePhoneVerification<Preferences extends Models.Preferences>(userId: string, phoneVerification: boolean): Promise<Models.User<Preferences>> {
+            if (typeof userId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "userId"');
+            }
+
+            if (typeof phoneVerification === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "phoneVerification"');
+            }
+
+            let path = '/users/{userId}/verification/phone'.replace('{userId}', userId);
+            let payload: Payload = {};
+
+            if (typeof phoneVerification !== 'undefined') {
+                payload['phoneVerification'] = phoneVerification;
+            }
+
+            const uri = new URL(this.client.config.endpoint + path);
+            return await this.client.call('patch', uri, {
+                'content-type': 'application/json',
+            }, payload);
+        }
+};