react-native-appwrite 0.2.2 → 0.3.1

package/src/services/account.ts

@@ -2,6 +2,12 @@ import { Service } from '../service';
 import { AppwriteException, Client } from '../client';
 import type { Models } from '../models';
 import type { UploadProgress, Payload } from '../client';
+import * as FileSystem from 'expo-file-system';
+import { Platform } from 'react-native';
+
+import { AuthenticatorType } from '../enums/authenticator-type';
+import { AuthenticationFactor } from '../enums/authentication-factor';
+import { OAuthProvider } from '../enums/o-auth-provider';
 
 export class Account extends Service {
 
@@ -132,11 +138,11 @@ export class Account extends Service {
      *
      * Get the list of identities for the currently logged in user.
      *
-     * @param {string} queries
+     * @param {string[]} queries
      * @throws {AppwriteException}
      * @returns {Promise}
     */
-    async listIdentities(queries?: string): Promise<Models.IdentityList> {
+    async listIdentities(queries?: string[]): Promise<Models.IdentityList> {
         const apiPath = '/account/identities';
         const payload: Payload = {};
 
@@ -151,7 +157,7 @@ export class Account extends Service {
     }
 
     /**
-     * Delete Identity
+     * Delete identity
      *
      * Delete an identity by its unique ID.
      *
@@ -219,6 +225,276 @@ export class Account extends Service {
         }, payload);
     }
 
+    /**
+     * Update MFA
+     *
+     * Enable or disable MFA on an account.
+     *
+     * @param {boolean} mfa
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async updateMFA<Preferences extends Models.Preferences>(mfa: boolean): Promise<Models.User<Preferences>> {
+        if (typeof mfa === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "mfa"');
+        }
+
+        const apiPath = '/account/mfa';
+        const payload: Payload = {};
+
+        if (typeof mfa !== 'undefined') {
+            payload['mfa'] = mfa;
+        }
+
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        return await this.client.call('patch', uri, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Add Authenticator
+     *
+     * Add an authenticator app to be used as an MFA factor. Verify the
+     * authenticator using the [verify
+     * authenticator](/docs/references/cloud/client-web/account#updateMfaAuthenticator)
+     * method.
+     *
+     * @param {AuthenticatorType} type
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async createMfaAuthenticator(type: AuthenticatorType): Promise<Models.MfaType> {
+        if (typeof type === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "type"');
+        }
+
+        const apiPath = '/account/mfa/authenticators/{type}'.replace('{type}', type);
+        const payload: Payload = {};
+
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        return await this.client.call('post', uri, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Verify Authenticator
+     *
+     * Verify an authenticator app after adding it using the [add
+     * authenticator](/docs/references/cloud/client-web/account#createMfaAuthenticator)
+     * method. add 
+     *
+     * @param {AuthenticatorType} type
+     * @param {string} otp
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async updateMfaAuthenticator<Preferences extends Models.Preferences>(type: AuthenticatorType, otp: string): Promise<Models.User<Preferences>> {
+        if (typeof type === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "type"');
+        }
+
+        if (typeof otp === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "otp"');
+        }
+
+        const apiPath = '/account/mfa/authenticators/{type}'.replace('{type}', type);
+        const payload: Payload = {};
+
+        if (typeof otp !== 'undefined') {
+            payload['otp'] = otp;
+        }
+
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        return await this.client.call('put', uri, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Delete Authenticator
+     *
+     * Delete an authenticator for a user by ID.
+     *
+     * @param {AuthenticatorType} type
+     * @param {string} otp
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async deleteMfaAuthenticator(type: AuthenticatorType, otp: string): Promise<{}> {
+        if (typeof type === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "type"');
+        }
+
+        if (typeof otp === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "otp"');
+        }
+
+        const apiPath = '/account/mfa/authenticators/{type}'.replace('{type}', type);
+        const payload: Payload = {};
+
+        if (typeof otp !== 'undefined') {
+            payload['otp'] = otp;
+        }
+
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        return await this.client.call('delete', uri, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Create 2FA Challenge
+     *
+     * Begin the process of MFA verification after sign-in. Finish the flow with
+     * [updateMfaChallenge](/docs/references/cloud/client-web/account#updateMfaChallenge)
+     * method.
+     *
+     * @param {AuthenticationFactor} factor
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async createMfaChallenge(factor: AuthenticationFactor): Promise<Models.MfaChallenge> {
+        if (typeof factor === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "factor"');
+        }
+
+        const apiPath = '/account/mfa/challenge';
+        const payload: Payload = {};
+
+        if (typeof factor !== 'undefined') {
+            payload['factor'] = factor;
+        }
+
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        return await this.client.call('post', uri, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Create MFA Challenge (confirmation)
+     *
+     * Complete the MFA challenge by providing the one-time password. Finish the
+     * process of MFA verification by providing the one-time password. To begin
+     * the flow, use
+     * [createMfaChallenge](/docs/references/cloud/client-web/account#createMfaChallenge)
+     * method.
+     *
+     * @param {string} challengeId
+     * @param {string} otp
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async updateMfaChallenge(challengeId: string, otp: string): Promise<{}> {
+        if (typeof challengeId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "challengeId"');
+        }
+
+        if (typeof otp === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "otp"');
+        }
+
+        const apiPath = '/account/mfa/challenge';
+        const payload: Payload = {};
+
+        if (typeof challengeId !== 'undefined') {
+            payload['challengeId'] = challengeId;
+        }
+
+        if (typeof otp !== 'undefined') {
+            payload['otp'] = otp;
+        }
+
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        return await this.client.call('put', uri, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * List Factors
+     *
+     * List the factors available on the account to be used as a MFA challange.
+     *
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async listMfaFactors(): Promise<Models.MfaFactors> {
+        const apiPath = '/account/mfa/factors';
+        const payload: Payload = {};
+
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        return await this.client.call('get', uri, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Get MFA Recovery Codes
+     *
+     * Get recovery codes that can be used as backup for MFA flow. Before getting
+     * codes, they must be generated using
+     * [createMfaRecoveryCodes](/docs/references/cloud/client-web/account#createMfaRecoveryCodes)
+     * method. An OTP challenge is required to read recovery codes.
+     *
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async getMfaRecoveryCodes(): Promise<Models.MfaRecoveryCodes> {
+        const apiPath = '/account/mfa/recovery-codes';
+        const payload: Payload = {};
+
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        return await this.client.call('get', uri, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Create MFA Recovery Codes
+     *
+     * Generate recovery codes as backup for MFA flow. It's recommended to
+     * generate and show then immediately after user successfully adds their
+     * authehticator. Recovery codes can be used as a MFA verification type in
+     * [createMfaChallenge](/docs/references/cloud/client-web/account#createMfaChallenge)
+     * method.
+     *
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async createMfaRecoveryCodes(): Promise<Models.MfaRecoveryCodes> {
+        const apiPath = '/account/mfa/recovery-codes';
+        const payload: Payload = {};
+
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        return await this.client.call('post', uri, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Regenerate MFA Recovery Codes
+     *
+     * Regenerate recovery codes that can be used as backup for MFA flow. Before
+     * regenerating codes, they must be first generated using
+     * [createMfaRecoveryCodes](/docs/references/cloud/client-web/account#createMfaRecoveryCodes)
+     * method. An OTP challenge is required to regenreate recovery codes.
+     *
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async updateMfaRecoveryCodes(): Promise<Models.MfaRecoveryCodes> {
+        const apiPath = '/account/mfa/recovery-codes';
+        const payload: Payload = {};
+
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        return await this.client.call('patch', uri, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
     /**
      * Update name
      *
@@ -345,11 +621,11 @@ export class Account extends Service {
      * stored as is, and replaces any previous value. The maximum allowed prefs
      * size is 64kB and throws error if exceeded.
      *
-     * @param {Partial<Preferences>} prefs
+     * @param {object} prefs
      * @throws {AppwriteException}
      * @returns {Promise}
     */
-    async updatePrefs<Preferences extends Models.Preferences>(prefs: Partial<Preferences>): Promise<Models.User<Preferences>> {
+    async updatePrefs<Preferences extends Models.Preferences>(prefs: object): Promise<Models.User<Preferences>> {
         if (typeof prefs === 'undefined') {
             throw new AppwriteException('Missing required parameter: "prefs"');
         }
@@ -427,11 +703,10 @@ export class Account extends Service {
      * @param {string} userId
      * @param {string} secret
      * @param {string} password
-     * @param {string} passwordAgain
      * @throws {AppwriteException}
      * @returns {Promise}
     */
-    async updateRecovery(userId: string, secret: string, password: string, passwordAgain: string): Promise<Models.Token> {
+    async updateRecovery(userId: string, secret: string, password: string): Promise<Models.Token> {
         if (typeof userId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "userId"');
         }
@@ -444,10 +719,6 @@ export class Account extends Service {
             throw new AppwriteException('Missing required parameter: "password"');
         }
 
-        if (typeof passwordAgain === 'undefined') {
-            throw new AppwriteException('Missing required parameter: "passwordAgain"');
-        }
-
         const apiPath = '/account/recovery';
         const payload: Payload = {};
 
@@ -463,10 +734,6 @@ export class Account extends Service {
             payload['password'] = password;
         }
 
-        if (typeof passwordAgain !== 'undefined') {
-            payload['passwordAgain'] = passwordAgain;
-        }
-
         const uri = new URL(this.client.config.endpoint + apiPath);
         return await this.client.call('put', uri, {
             'content-type': 'application/json',
@@ -536,7 +803,7 @@ export class Account extends Service {
     }
 
     /**
-     * Create email session
+     * Create email password session
      *
      * Allow the user to login into their account by providing a valid email and
      * password combination. This route will create a new session for the user.
@@ -550,7 +817,7 @@ export class Account extends Service {
      * @throws {AppwriteException}
      * @returns {Promise}
     */
-    async createEmailSession(email: string, password: string): Promise<Models.Session> {
+    async createEmailPasswordSession(email: string, password: string): Promise<Models.Session> {
         if (typeof email === 'undefined') {
             throw new AppwriteException('Missing required parameter: "email"');
         }
@@ -577,75 +844,11 @@ export class Account extends Service {
     }
 
     /**
-     * Create magic URL session
-     *
-     * Sends the user an email with a secret key for creating a session. If the
-     * provided user ID has not been registered, a new user will be created. When
-     * the user clicks the link in the email, the user is redirected back to the
-     * URL you provided with the secret key and userId values attached to the URL
-     * query string. Use the query string parameters to submit a request to the
-     * [PUT
-     * /account/sessions/magic-url](https://appwrite.io/docs/references/cloud/client-web/account#updateMagicURLSession)
-     * endpoint to complete the login process. The link sent to the user's email
-     * address is valid for 1 hour. If you are on a mobile device you can leave
-     * the URL parameter empty, so that the login completion will be handled by
-     * your Appwrite instance by default.
-     * 
-     * A user is limited to 10 active sessions at a time by default. [Learn more
-     * about session
-     * limits](https://appwrite.io/docs/authentication-security#limits).
-     * 
-     *
-     * @param {string} userId
-     * @param {string} email
-     * @param {string} url
-     * @throws {AppwriteException}
-     * @returns {Promise}
-    */
-    async createMagicURLSession(userId: string, email: string, url?: string): Promise<Models.Token> {
-        if (typeof userId === 'undefined') {
-            throw new AppwriteException('Missing required parameter: "userId"');
-        }
-
-        if (typeof email === 'undefined') {
-            throw new AppwriteException('Missing required parameter: "email"');
-        }
-
-        const apiPath = '/account/sessions/magic-url';
-        const payload: Payload = {};
-
-        if (typeof userId !== 'undefined') {
-            payload['userId'] = userId;
-        }
-
-        if (typeof email !== 'undefined') {
-            payload['email'] = email;
-        }
-
-        if (typeof url !== 'undefined') {
-            payload['url'] = url;
-        }
-
-        const uri = new URL(this.client.config.endpoint + apiPath);
-        return await this.client.call('post', uri, {
-            'content-type': 'application/json',
-        }, payload);
-    }
-
-    /**
-     * Create magic URL session (confirmation)
+     * Update magic URL session
      *
-     * Use this endpoint to complete creating the session with the Magic URL. Both
-     * the **userId** and **secret** arguments will be passed as query parameters
-     * to the redirect URL you have provided when sending your request to the
-     * [POST
-     * /account/sessions/magic-url](https://appwrite.io/docs/references/cloud/client-web/account#createMagicURLSession)
-     * endpoint.
-     * 
-     * Please note that in order to avoid a [Redirect
-     * Attack](https://github.com/OWASP/CheatSheetSeries/blob/master/cheatsheets/Unvalidated_Redirects_and_Forwards_Cheat_Sheet.md)
-     * the only valid redirect URLs are the ones from domains you have set when
-     * adding your platforms in the console interface.
+     * Use this endpoint to create a session from token. Provide the **userId**
+     * and **secret** parameters from the successful response of authentication
+     * flows initiated by token creation. For example, magic URL and phone login.
      *
      * @param {string} userId
      * @param {string} secret
@@ -698,43 +901,62 @@ export class Account extends Service {
      * limits](https://appwrite.io/docs/authentication-security#limits).
      * 
      *
-     * @param {string} provider
+     * @param {OAuthProvider} provider
      * @param {string} success
      * @param {string} failure
      * @param {string[]} scopes
      * @throws {AppwriteException}
      * @returns {void|string}
     */
-    createOAuth2Session(provider: string, success?: string, failure?: string, scopes?: string[]): void | URL {
-        throw new AppwriteException('Not yet supported');
+    createOAuth2Session(provider: OAuthProvider, success?: string, failure?: string, scopes?: string[]): void | URL {
+        if (typeof provider === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "provider"');
+        }
+
+        const apiPath = '/account/sessions/oauth2/{provider}'.replace('{provider}', provider);
+        const payload: Payload = {};
+
+        if (typeof success !== 'undefined') {
+            payload['success'] = success;
+        }
+
+        if (typeof failure !== 'undefined') {
+            payload['failure'] = failure;
+        }
+
+        if (typeof scopes !== 'undefined') {
+            payload['scopes'] = scopes;
+        }
+
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        payload['project'] = this.client.config.project;
+
+
+        for (const [key, value] of Object.entries(Service.flatten(payload))) {
+            uri.searchParams.append(key, value);
+        }
+        return uri;
     }
 
     /**
-     * Create phone session
+     * Update phone session
      *
-     * Sends the user an SMS with a secret key for creating a session. If the
-     * provided user ID has not be registered, a new user will be created. Use the
-     * returned user ID and secret and submit a request to the [PUT
-     * /account/sessions/phone](https://appwrite.io/docs/references/cloud/client-web/account#updatePhoneSession)
-     * endpoint to complete the login process. The secret sent to the user's phone
-     * is valid for 15 minutes.
-     * 
-     * A user is limited to 10 active sessions at a time by default. [Learn more
-     * about session
-     * limits](https://appwrite.io/docs/authentication-security#limits).
+     * Use this endpoint to create a session from token. Provide the **userId**
+     * and **secret** parameters from the successful response of authentication
+     * flows initiated by token creation. For example, magic URL and phone login.
      *
      * @param {string} userId
-     * @param {string} phone
+     * @param {string} secret
      * @throws {AppwriteException}
      * @returns {Promise}
     */
-    async createPhoneSession(userId: string, phone: string): Promise<Models.Token> {
+    async updatePhoneSession(userId: string, secret: string): Promise<Models.Session> {
         if (typeof userId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "userId"');
         }
 
-        if (typeof phone === 'undefined') {
-            throw new AppwriteException('Missing required parameter: "phone"');
+        if (typeof secret === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "secret"');
         }
 
         const apiPath = '/account/sessions/phone';
@@ -744,31 +966,29 @@ export class Account extends Service {
             payload['userId'] = userId;
         }
 
-        if (typeof phone !== 'undefined') {
-            payload['phone'] = phone;
+        if (typeof secret !== 'undefined') {
+            payload['secret'] = secret;
         }
 
         const uri = new URL(this.client.config.endpoint + apiPath);
-        return await this.client.call('post', uri, {
+        return await this.client.call('put', uri, {
             'content-type': 'application/json',
         }, payload);
     }
 
     /**
-     * Create phone session (confirmation)
+     * Create session
      *
-     * Use this endpoint to complete creating a session with SMS. Use the
-     * **userId** from the
-     * [createPhoneSession](https://appwrite.io/docs/references/cloud/client-web/account#createPhoneSession)
-     * endpoint and the **secret** received via SMS to successfully update and
-     * confirm the phone session.
+     * Use this endpoint to create a session from token. Provide the **userId**
+     * and **secret** parameters from the successful response of authentication
+     * flows initiated by token creation. For example, magic URL and phone login.
      *
      * @param {string} userId
      * @param {string} secret
      * @throws {AppwriteException}
      * @returns {Promise}
     */
-    async updatePhoneSession(userId: string, secret: string): Promise<Models.Session> {
+    async createSession(userId: string, secret: string): Promise<Models.Session> {
         if (typeof userId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "userId"');
         }
@@ -777,7 +997,7 @@ export class Account extends Service {
             throw new AppwriteException('Missing required parameter: "secret"');
         }
 
-        const apiPath = '/account/sessions/phone';
+        const apiPath = '/account/sessions/token';
         const payload: Payload = {};
 
         if (typeof userId !== 'undefined') {
@@ -789,7 +1009,7 @@ export class Account extends Service {
         }
 
         const uri = new URL(this.client.config.endpoint + apiPath);
-        return await this.client.call('put', uri, {
+        return await this.client.call('post', uri, {
             'content-type': 'application/json',
         }, payload);
     }
@@ -819,11 +1039,11 @@ export class Account extends Service {
     }
 
     /**
-     * Update OAuth session (refresh tokens)
+     * Update session
      *
-     * Access tokens have limited lifespan and expire to mitigate security risks.
-     * If session was created using an OAuth provider, this route can be used to
-     * "refresh" the access token.
+     * Use this endpoint to extend a session's length. Extending a session is
+     * useful when session expiry is short. If the session was created using an
+     * OAuth provider, this endpoint refreshes the access token from the provider.
      *
      * @param {string} sessionId
      * @throws {AppwriteException}
@@ -890,6 +1110,310 @@ export class Account extends Service {
         }, payload);
     }
 
+    /**
+     * Create push target
+     *
+     *
+     * @param {string} targetId
+     * @param {string} identifier
+     * @param {string} providerId
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async createPushTarget(targetId: string, identifier: string, providerId?: string): Promise<Models.Target> {
+        if (typeof targetId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "targetId"');
+        }
+
+        if (typeof identifier === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "identifier"');
+        }
+
+        const apiPath = '/account/targets/push';
+        const payload: Payload = {};
+
+        if (typeof targetId !== 'undefined') {
+            payload['targetId'] = targetId;
+        }
+
+        if (typeof identifier !== 'undefined') {
+            payload['identifier'] = identifier;
+        }
+
+        if (typeof providerId !== 'undefined') {
+            payload['providerId'] = providerId;
+        }
+
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        return await this.client.call('post', uri, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Update push target
+     *
+     *
+     * @param {string} targetId
+     * @param {string} identifier
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async updatePushTarget(targetId: string, identifier: string): Promise<Models.Target> {
+        if (typeof targetId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "targetId"');
+        }
+
+        if (typeof identifier === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "identifier"');
+        }
+
+        const apiPath = '/account/targets/{targetId}/push'.replace('{targetId}', targetId);
+        const payload: Payload = {};
+
+        if (typeof identifier !== 'undefined') {
+            payload['identifier'] = identifier;
+        }
+
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        return await this.client.call('put', uri, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Delete push target
+     *
+     *
+     * @param {string} targetId
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async deletePushTarget(targetId: string): Promise<{}> {
+        if (typeof targetId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "targetId"');
+        }
+
+        const apiPath = '/account/targets/{targetId}/push'.replace('{targetId}', targetId);
+        const payload: Payload = {};
+
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        return await this.client.call('delete', uri, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Create email token (OTP)
+     *
+     * Sends the user an email with a secret key for creating a session. If the
+     * provided user ID has not be registered, a new user will be created. Use the
+     * returned user ID and secret and submit a request to the [POST
+     * /v1/account/sessions/token](https://appwrite.io/docs/references/cloud/client-web/account#createSession)
+     * endpoint to complete the login process. The secret sent to the user's email
+     * is valid for 15 minutes.
+     * 
+     * A user is limited to 10 active sessions at a time by default. [Learn more
+     * about session
+     * limits](https://appwrite.io/docs/authentication-security#limits).
+     *
+     * @param {string} userId
+     * @param {string} email
+     * @param {boolean} phrase
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async createEmailToken(userId: string, email: string, phrase?: boolean): Promise<Models.Token> {
+        if (typeof userId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "userId"');
+        }
+
+        if (typeof email === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "email"');
+        }
+
+        const apiPath = '/account/tokens/email';
+        const payload: Payload = {};
+
+        if (typeof userId !== 'undefined') {
+            payload['userId'] = userId;
+        }
+
+        if (typeof email !== 'undefined') {
+            payload['email'] = email;
+        }
+
+        if (typeof phrase !== 'undefined') {
+            payload['phrase'] = phrase;
+        }
+
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        return await this.client.call('post', uri, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Create magic URL token
+     *
+     * Sends the user an email with a secret key for creating a session. If the
+     * provided user ID has not been registered, a new user will be created. When
+     * the user clicks the link in the email, the user is redirected back to the
+     * URL you provided with the secret key and userId values attached to the URL
+     * query string. Use the query string parameters to submit a request to the
+     * [POST
+     * /v1/account/sessions/token](https://appwrite.io/docs/references/cloud/client-web/account#createSession)
+     * endpoint to complete the login process. The link sent to the user's email
+     * address is valid for 1 hour. If you are on a mobile device you can leave
+     * the URL parameter empty, so that the login completion will be handled by
+     * your Appwrite instance by default.
+     * 
+     * A user is limited to 10 active sessions at a time by default. [Learn more
+     * about session
+     * limits](https://appwrite.io/docs/authentication-security#limits).
+     * 
+     *
+     * @param {string} userId
+     * @param {string} email
+     * @param {string} url
+     * @param {boolean} phrase
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async createMagicURLToken(userId: string, email: string, url?: string, phrase?: boolean): Promise<Models.Token> {
+        if (typeof userId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "userId"');
+        }
+
+        if (typeof email === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "email"');
+        }
+
+        const apiPath = '/account/tokens/magic-url';
+        const payload: Payload = {};
+
+        if (typeof userId !== 'undefined') {
+            payload['userId'] = userId;
+        }
+
+        if (typeof email !== 'undefined') {
+            payload['email'] = email;
+        }
+
+        if (typeof url !== 'undefined') {
+            payload['url'] = url;
+        }
+
+        if (typeof phrase !== 'undefined') {
+            payload['phrase'] = phrase;
+        }
+
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        return await this.client.call('post', uri, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Create OAuth2 token
+     *
+     * Allow the user to login to their account using the OAuth2 provider of their
+     * choice. Each OAuth2 provider should be enabled from the Appwrite console
+     * first. Use the success and failure arguments to provide a redirect URL's
+     * back to your app when login is completed. 
+     * 
+     * If authentication succeeds, `userId` and `secret` of a token will be
+     * appended to the success URL as query parameters. These can be used to
+     * create a new session using the [Create
+     * session](https://appwrite.io/docs/references/cloud/client-web/account#createSession)
+     * endpoint.
+     * 
+     * A user is limited to 10 active sessions at a time by default. [Learn more
+     * about session
+     * limits](https://appwrite.io/docs/authentication-security#limits).
+     *
+     * @param {OAuthProvider} provider
+     * @param {string} success
+     * @param {string} failure
+     * @param {string[]} scopes
+     * @throws {AppwriteException}
+     * @returns {void|string}
+    */
+    createOAuth2Token(provider: OAuthProvider, success?: string, failure?: string, scopes?: string[]): void | URL {
+        if (typeof provider === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "provider"');
+        }
+
+        const apiPath = '/account/tokens/oauth2/{provider}'.replace('{provider}', provider);
+        const payload: Payload = {};
+
+        if (typeof success !== 'undefined') {
+            payload['success'] = success;
+        }
+
+        if (typeof failure !== 'undefined') {
+            payload['failure'] = failure;
+        }
+
+        if (typeof scopes !== 'undefined') {
+            payload['scopes'] = scopes;
+        }
+
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        payload['project'] = this.client.config.project;
+
+
+        for (const [key, value] of Object.entries(Service.flatten(payload))) {
+            uri.searchParams.append(key, value);
+        }
+        return uri;
+    }
+
+    /**
+     * Create phone token
+     *
+     * Sends the user an SMS with a secret key for creating a session. If the
+     * provided user ID has not be registered, a new user will be created. Use the
+     * returned user ID and secret and submit a request to the [POST
+     * /v1/account/sessions/token](https://appwrite.io/docs/references/cloud/client-web/account#createSession)
+     * endpoint to complete the login process. The secret sent to the user's phone
+     * is valid for 15 minutes.
+     * 
+     * A user is limited to 10 active sessions at a time by default. [Learn more
+     * about session
+     * limits](https://appwrite.io/docs/authentication-security#limits).
+     *
+     * @param {string} userId
+     * @param {string} phone
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async createPhoneToken(userId: string, phone: string): Promise<Models.Token> {
+        if (typeof userId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "userId"');
+        }
+
+        if (typeof phone === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "phone"');
+        }
+
+        const apiPath = '/account/tokens/phone';
+        const payload: Payload = {};
+
+        if (typeof userId !== 'undefined') {
+            payload['userId'] = userId;
+        }
+
+        if (typeof phone !== 'undefined') {
+            payload['phone'] = phone;
+        }
+
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        return await this.client.call('post', uri, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
     /**
      * Create email verification
      *