@appwrite.io/console 0.5.0 → 0.6.0-rc.10

package/src/services/account.ts

@@ -2,6 +2,10 @@ import { Service } from '../service';
 import { AppwriteException, Client } from '../client';
 import type { Models } from '../models';
 import type { UploadProgress, Payload } from '../client';
+import { Query } from '../query';
+import { Factor } from '../enums/factor';
+import { Type } from '../enums/type';
+import { OAuthProvider } from '../enums/o-auth-provider';
 
 export class Account extends Service {
 
@@ -150,11 +154,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 = {};
 
@@ -169,7 +173,7 @@ export class Account extends Service {
     }
 
     /**
-     * Delete Identity
+     * Delete identity
      *
      * Delete an identity by its unique ID.
      *
@@ -237,6 +241,194 @@ export class Account extends Service {
         }, payload);
     }
 
+    /**
+     * Update MFA
+     *
+     *
+     * @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);
+    }
+
+    /**
+     * Create 2FA Challenge
+     *
+     *
+     * @param {Factor} factor
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async create2FAChallenge(factor: Factor): 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)
+     *
+     *
+     * @param {string} challengeId
+     * @param {string} otp
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async updateChallenge(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
+     *
+     *
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async listFactors(): 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);
+    }
+
+    /**
+     * Add Authenticator
+     *
+     *
+     * @param {Type} type
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async addAuthenticator(type: Type): Promise<Models.MfaType> {
+        if (typeof type === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "type"');
+        }
+
+        const apiPath = '/account/mfa/{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
+     *
+     *
+     * @param {Type} type
+     * @param {string} otp
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async verifyAuthenticator<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/{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
+     *
+     *
+     * @param {Type} type
+     * @param {string} otp
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async deleteAuthenticator<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/{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);
+    }
+
     /**
      * Update name
      *
@@ -445,11 +637,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"');
         }
@@ -462,10 +653,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 = {};
 
@@ -481,10 +668,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',
@@ -554,7 +737,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.
@@ -568,7 +751,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"');
         }
@@ -595,75 +778,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)
+     * Create session (deprecated)
      *
-     * 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
@@ -716,14 +835,15 @@ 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 {boolean} token
      * @param {string[]} scopes
      * @throws {AppwriteException}
      * @returns {void|string}
     */
-    createOAuth2Session(provider: string, success?: string, failure?: string, scopes?: string[]): void | URL {
+    createOAuth2Session(provider: OAuthProvider, success?: string, failure?: string, token?: boolean, scopes?: string[]): void | URL {
         if (typeof provider === 'undefined') {
             throw new AppwriteException('Missing required parameter: "provider"');
         }
@@ -739,6 +859,10 @@ export class Account extends Service {
             payload['failure'] = failure;
         }
 
+        if (typeof token !== 'undefined') {
+            payload['token'] = token;
+        }
+
         if (typeof scopes !== 'undefined') {
             payload['scopes'] = scopes;
         }
@@ -758,65 +882,18 @@ export class Account extends Service {
     }
 
     /**
-     * Create phone session
+     * Create 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).
-     *
-     * @param {string} userId
-     * @param {string} phone
-     * @throws {AppwriteException}
-     * @returns {Promise}
-    */
-    async createPhoneSession(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/sessions/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 phone session (confirmation)
-     *
-     * 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"');
         }
@@ -825,7 +902,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') {
@@ -837,7 +914,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);
     }
@@ -867,11 +944,10 @@ export class Account extends Service {
     }
 
     /**
-     * Update OAuth session (refresh tokens)
+     * Update (or renew) a 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.
+     * Extend session's expiry to increase it's lifespan. Extending a session is
+     * useful when session length is short such as 5 minutes.
      *
      * @param {string} sessionId
      * @throws {AppwriteException}
@@ -938,6 +1014,255 @@ export class Account extends Service {
         }, payload);
     }
 
+    /**
+     * Create a 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 a 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 a 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 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
      *