@appwrite.io/console 0.6.0-rc.14 → 0.6.0-rc.15

package/src/models.ts

@@ -1186,10 +1186,6 @@ export namespace Models {
          * Multi factor authentication status.
          */
         mfa: boolean;
-        /**
-         * TOTP status.
-         */
-        totp: boolean;
         /**
          * User preferences as a key-value object
          */
@@ -1424,6 +1420,10 @@ export namespace Models {
          * Secret used to authenticate the user. Only included if the request was made with an API key
          */
         secret: string;
+        /**
+         * Most recent date in ISO 8601 format when the session successfully passed MFA challenge.
+         */
+        mfaUpdatedAt: string;
     }
     /**
      * Identity
@@ -3240,13 +3240,18 @@ export namespace Models {
         expire: string;
     }
     /**
-     * MFAType
+     * MFA Recovery Codes
      */
-    export type MfaType = {
+    export type MfaRecoveryCodes = {
         /**
-         * Backup codes.
+         * Recovery codes.
          */
-        backups: string[];
+        recoveryCodes: string[];
+    }
+    /**
+     * MFAType
+     */
+    export type MfaType = {
         /**
          * Secret token used for TOTP factor.
          */

package/src/services/account.ts

@@ -2,8 +2,8 @@ import { Service } from '../service';
 import { AppwriteException, Client } from '../client';
 import type { Models } from '../models';
 import type { UploadProgress, Payload } from '../client';
-import { AuthenticationFactor } from '../enums/authentication-factor';
-import { AuthenticatorType } from '../enums/authenticator-type';
+import { Type } from '../enums/type';
+import { Factor } from '../enums/factor';
 import { OAuthProvider } from '../enums/o-auth-provider';
 
 export class Account extends Service {
@@ -267,15 +267,110 @@ export class Account extends Service {
         }, 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#verifyAuthenticator)
+     * method.
+     *
+     * @param {Type} type
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async createMfaAuthenticator(type: Type): 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#addAuthenticator)
+     * method.
+     *
+     * @param {Type} type
+     * @param {string} otp
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async updateMfaAuthenticator<Preferences extends Models.Preferences>(type: Type, 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 {Type} type
+     * @param {string} otp
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async deleteMfaAuthenticator<Preferences extends Models.Preferences>(type: Type, 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('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
+     * @param {Factor} factor
      * @throws {AppwriteException}
      * @returns {Promise}
     */
-    async createChallenge(factor: AuthenticationFactor): Promise<Models.MfaChallenge> {
+    async createMfaChallenge(factor: Factor): Promise<Models.MfaChallenge> {
         if (typeof factor === 'undefined') {
             throw new AppwriteException('Missing required parameter: "factor"');
         }
@@ -296,14 +391,18 @@ export class Account extends Service {
     /**
      * Create MFA Challenge (confirmation)
      *
-     * Complete the MFA challenge by providing the one-time password.
+     * 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 updateChallenge(challengeId: string, otp: string): Promise<{}> {
+    async updateMfaChallenge(challengeId: string, otp: string): Promise<{}> {
         if (typeof challengeId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "challengeId"');
         }
@@ -337,7 +436,7 @@ export class Account extends Service {
      * @throws {AppwriteException}
      * @returns {Promise}
     */
-    async listFactors(): Promise<Models.MfaFactors> {
+    async listMfaFactors(): Promise<Models.MfaFactors> {
         const apiPath = '/account/mfa/factors';
         const payload: Payload = {};
 
@@ -348,93 +447,65 @@ export class Account extends Service {
     }
 
     /**
-     * Add Authenticator
+     * Get MFA Recovery Codes
      *
-     * Add an authenticator app to be used as an MFA factor. Verify the
-     * authenticator using the [verify
-     * authenticator](/docs/references/cloud/client-web/account#verifyAuthenticator)
-     * method.
+     * 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.
      *
-     * @param {AuthenticatorType} type
      * @throws {AppwriteException}
      * @returns {Promise}
     */
-    async addAuthenticator(type: AuthenticatorType): Promise<Models.MfaType> {
-        if (typeof type === 'undefined') {
-            throw new AppwriteException('Missing required parameter: "type"');
-        }
-
-        const apiPath = '/account/mfa/{type}'.replace('{type}', type);
+    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('post', uri, {
+        return await this.client.call('get', uri, {
             'content-type': 'application/json',
         }, payload);
     }
 
     /**
-     * Verify Authenticator
+     * Create MFA Recovery Codes
      *
-     * Verify an authenticator app after adding it using the [add
-     * authenticator](/docs/references/cloud/client-web/account#addAuthenticator)
+     * 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.
      *
-     * @param {AuthenticatorType} type
-     * @param {string} otp
      * @throws {AppwriteException}
      * @returns {Promise}
     */
-    async verifyAuthenticator<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/{type}'.replace('{type}', type);
+    async createMfaRecoveryCodes(): Promise<Models.MfaRecoveryCodes> {
+        const apiPath = '/account/mfa/recovery-codes';
         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, {
+        return await this.client.call('post', uri, {
             'content-type': 'application/json',
         }, payload);
     }
 
     /**
-     * Delete Authenticator
+     * Regenerate MFA Recovery Codes
      *
-     * Delete an authenticator for a user by ID.
+     * 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.
      *
-     * @param {AuthenticatorType} type
-     * @param {string} otp
      * @throws {AppwriteException}
      * @returns {Promise}
     */
-    async deleteAuthenticator<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/{type}'.replace('{type}', type);
+    async updateMfaRecoveryCodes(): Promise<Models.MfaRecoveryCodes> {
+        const apiPath = '/account/mfa/recovery-codes';
         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, {
+        return await this.client.call('patch', uri, {
             'content-type': 'application/json',
         }, payload);
     }

package/src/services/users.ts

@@ -4,7 +4,7 @@ import type { Models } from '../models';
 import type { UploadProgress, Payload } from '../client';
 import { PasswordHash } from '../enums/password-hash';
 import { UserUsageRange } from '../enums/user-usage-range';
-import { AuthenticatorType } from '../enums/authenticator-type';
+import { Type } from '../enums/type';
 import { MessagingProviderType } from '../enums/messaging-provider-type';
 
 export class Users extends Service {
@@ -815,6 +815,34 @@ export class Users extends Service {
         }, payload);
     }
 
+    /**
+     * Delete Authenticator
+     *
+     * Delete an authenticator app.
+     *
+     * @param {string} userId
+     * @param {Type} type
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async deleteMfaAuthenticator<Preferences extends Models.Preferences>(userId: string, type: Type): Promise<Models.User<Preferences>> {
+        if (typeof userId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "userId"');
+        }
+
+        if (typeof type === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "type"');
+        }
+
+        const apiPath = '/users/{userId}/mfa/authenticators/{type}'.replace('{userId}', userId).replace('{type}', type);
+        const payload: Payload = {};
+
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        return await this.client.call('delete', uri, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
     /**
      * List Factors
      *
@@ -824,7 +852,7 @@ export class Users extends Service {
      * @throws {AppwriteException}
      * @returns {Promise}
     */
-    async listFactors(userId: string): Promise<Models.MfaFactors> {
+    async listMfaFactors(userId: string): Promise<Models.MfaFactors> {
         if (typeof userId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "userId"');
         }
@@ -839,29 +867,79 @@ export class Users extends Service {
     }
 
     /**
-     * Delete Authenticator
+     * Get MFA Recovery Codes
      *
-     * Delete an authenticator app.
+     * Get recovery codes that can be used as backup for MFA flow by User ID.
+     * Before getting codes, they must be generated using
+     * [createMfaRecoveryCodes](/docs/references/cloud/client-web/account#createMfaRecoveryCodes)
+     * method.
      *
      * @param {string} userId
-     * @param {AuthenticatorType} type
      * @throws {AppwriteException}
      * @returns {Promise}
     */
-    async deleteAuthenticator<Preferences extends Models.Preferences>(userId: string, type: AuthenticatorType): Promise<Models.User<Preferences>> {
+    async getMfaRecoveryCodes(userId: string): Promise<Models.MfaRecoveryCodes> {
         if (typeof userId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "userId"');
         }
 
-        if (typeof type === 'undefined') {
-            throw new AppwriteException('Missing required parameter: "type"');
+        const apiPath = '/users/{userId}/mfa/recovery-codes'.replace('{userId}', userId);
+        const payload: Payload = {};
+
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        return await this.client.call('get', uri, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Regenerate MFA Recovery Codes
+     *
+     * Regenerate recovery codes that can be used as backup for MFA flow by User
+     * ID. Before regenerating codes, they must be first generated using
+     * [createMfaRecoveryCodes](/docs/references/cloud/client-web/account#createMfaRecoveryCodes)
+     * method.
+     *
+     * @param {string} userId
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async updateMfaRecoveryCodes(userId: string): Promise<Models.MfaRecoveryCodes> {
+        if (typeof userId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "userId"');
         }
 
-        const apiPath = '/users/{userId}/mfa/{type}'.replace('{userId}', userId).replace('{type}', type);
+        const apiPath = '/users/{userId}/mfa/recovery-codes'.replace('{userId}', userId);
         const payload: Payload = {};
 
         const uri = new URL(this.client.config.endpoint + apiPath);
-        return await this.client.call('delete', uri, {
+        return await this.client.call('put', uri, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Create MFA Recovery Codes
+     *
+     * Generate recovery codes used as backup for MFA flow for User ID. Recovery
+     * codes can be used as a MFA verification type in
+     * [createMfaChallenge](/docs/references/cloud/client-web/account#createMfaChallenge)
+     * method by client SDK.
+     *
+     * @param {string} userId
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async createMfaRecoveryCodes(userId: string): Promise<Models.MfaRecoveryCodes> {
+        if (typeof userId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "userId"');
+        }
+
+        const apiPath = '/users/{userId}/mfa/recovery-codes'.replace('{userId}', userId);
+        const payload: Payload = {};
+
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        return await this.client.call('patch', uri, {
             'content-type': 'application/json',
         }, payload);
     }

package/types/enums/factor.d.ts

@@ -0,0 +1,6 @@
+export declare enum Factor {
+    Email = "email",
+    Phone = "phone",
+    Totp = "totp",
+    Recoverycode = "recoverycode"
+}

package/types/enums/type.d.ts

@@ -0,0 +1,3 @@
+export declare enum Type {
+    Totp = "totp"
+}

package/types/index.d.ts

@@ -22,8 +22,8 @@ export type { QueryTypes, QueryTypesList } from './query';
 export { Permission } from './permission';
 export { Role } from './role';
 export { ID } from './id';
-export { AuthenticationFactor } from './enums/authentication-factor';
-export { AuthenticatorType } from './enums/authenticator-type';
+export { Type } from './enums/type';
+export { Factor } from './enums/factor';
 export { OAuthProvider } from './enums/o-auth-provider';
 export { Browser } from './enums/browser';
 export { CreditCard } from './enums/credit-card';

package/types/models.d.ts

@@ -1186,10 +1186,6 @@ export declare namespace Models {
          * Multi factor authentication status.
          */
         mfa: boolean;
-        /**
-         * TOTP status.
-         */
-        totp: boolean;
         /**
          * User preferences as a key-value object
          */
@@ -1424,6 +1420,10 @@ export declare namespace Models {
          * Secret used to authenticate the user. Only included if the request was made with an API key
          */
         secret: string;
+        /**
+         * Most recent date in ISO 8601 format when the session successfully passed MFA challenge.
+         */
+        mfaUpdatedAt: string;
     };
     /**
      * Identity
@@ -3240,13 +3240,18 @@ export declare namespace Models {
         expire: string;
     };
     /**
-     * MFAType
+     * MFA Recovery Codes
      */
-    type MfaType = {
+    type MfaRecoveryCodes = {
         /**
-         * Backup codes.
+         * Recovery codes.
          */
-        backups: string[];
+        recoveryCodes: string[];
+    };
+    /**
+     * MFAType
+     */
+    type MfaType = {
         /**
          * Secret token used for TOTP factor.
          */

package/types/services/account.d.ts

@@ -1,8 +1,8 @@
 import { Service } from '../service';
 import { Client } from '../client';
 import type { Models } from '../models';
-import { AuthenticationFactor } from '../enums/authentication-factor';
-import { AuthenticatorType } from '../enums/authenticator-type';
+import { Type } from '../enums/type';
+import { Factor } from '../enums/factor';
 import { OAuthProvider } from '../enums/o-auth-provider';
 export declare class Account extends Service {
     constructor(client: Client);
@@ -115,26 +115,70 @@ export declare class Account extends Service {
      * @returns {Promise}
     */
     updateMFA<Preferences extends Models.Preferences>(mfa: boolean): Promise<Models.User<Preferences>>;
+    /**
+     * 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#verifyAuthenticator)
+     * method.
+     *
+     * @param {Type} type
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    createMfaAuthenticator(type: Type): Promise<Models.MfaType>;
+    /**
+     * Verify Authenticator
+     *
+     * Verify an authenticator app after adding it using the [add
+     * authenticator](/docs/references/cloud/client-web/account#addAuthenticator)
+     * method.
+     *
+     * @param {Type} type
+     * @param {string} otp
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    updateMfaAuthenticator<Preferences extends Models.Preferences>(type: Type, otp: string): Promise<Models.User<Preferences>>;
+    /**
+     * Delete Authenticator
+     *
+     * Delete an authenticator for a user by ID.
+     *
+     * @param {Type} type
+     * @param {string} otp
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    deleteMfaAuthenticator<Preferences extends Models.Preferences>(type: Type, otp: string): Promise<Models.User<Preferences>>;
     /**
      * 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
+     * @param {Factor} factor
      * @throws {AppwriteException}
      * @returns {Promise}
     */
-    createChallenge(factor: AuthenticationFactor): Promise<Models.MfaChallenge>;
+    createMfaChallenge(factor: Factor): Promise<Models.MfaChallenge>;
     /**
      * Create MFA Challenge (confirmation)
      *
-     * Complete the MFA challenge by providing the one-time password.
+     * 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}
     */
-    updateChallenge(challengeId: string, otp: string): Promise<{}>;
+    updateMfaChallenge(challengeId: string, otp: string): Promise<{}>;
     /**
      * List Factors
      *
@@ -143,44 +187,44 @@ export declare class Account extends Service {
      * @throws {AppwriteException}
      * @returns {Promise}
     */
-    listFactors(): Promise<Models.MfaFactors>;
+    listMfaFactors(): Promise<Models.MfaFactors>;
     /**
-     * Add Authenticator
+     * Get MFA Recovery Codes
      *
-     * Add an authenticator app to be used as an MFA factor. Verify the
-     * authenticator using the [verify
-     * authenticator](/docs/references/cloud/client-web/account#verifyAuthenticator)
-     * method.
+     * 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.
      *
-     * @param {AuthenticatorType} type
      * @throws {AppwriteException}
      * @returns {Promise}
     */
-    addAuthenticator(type: AuthenticatorType): Promise<Models.MfaType>;
+    getMfaRecoveryCodes(): Promise<Models.MfaRecoveryCodes>;
     /**
-     * Verify Authenticator
+     * Create MFA Recovery Codes
      *
-     * Verify an authenticator app after adding it using the [add
-     * authenticator](/docs/references/cloud/client-web/account#addAuthenticator)
+     * 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.
      *
-     * @param {AuthenticatorType} type
-     * @param {string} otp
      * @throws {AppwriteException}
      * @returns {Promise}
     */
-    verifyAuthenticator<Preferences extends Models.Preferences>(type: AuthenticatorType, otp: string): Promise<Models.User<Preferences>>;
+    createMfaRecoveryCodes(): Promise<Models.MfaRecoveryCodes>;
     /**
-     * Delete Authenticator
+     * Regenerate MFA Recovery Codes
      *
-     * Delete an authenticator for a user by ID.
+     * 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.
      *
-     * @param {AuthenticatorType} type
-     * @param {string} otp
      * @throws {AppwriteException}
      * @returns {Promise}
     */
-    deleteAuthenticator<Preferences extends Models.Preferences>(type: AuthenticatorType, otp: string): Promise<Models.User<Preferences>>;
+    updateMfaRecoveryCodes(): Promise<Models.MfaRecoveryCodes>;
     /**
      * Update name
      *