@appwrite.io/console 0.6.0-rc.8 → 0.6.0

package/src/services/migrations.ts

@@ -14,12 +14,12 @@ export class Migrations extends Service {
      * List Migrations
      *
      *
-     * @param {string} queries
+     * @param {string[]} queries
      * @param {string} search
      * @throws {AppwriteException}
      * @returns {Promise}
     */
-    async list(queries?: string, search?: string): Promise<Models.MigrationList> {
+    async list(queries?: string[], search?: string): Promise<Models.MigrationList> {
         const apiPath = '/migrations';
         const payload: Payload = {};
 

package/src/services/project.ts

@@ -2,6 +2,7 @@ import { Service } from '../service';
 import { AppwriteException, Client } from '../client';
 import type { Models } from '../models';
 import type { UploadProgress, Payload } from '../client';
+import { ProjectUsageRange } from '../enums/project-usage-range';
 
 export class Project extends Service {
 
@@ -11,16 +12,16 @@ export class Project extends Service {
      }
 
     /**
-     * Get usage stats for a project
+     * Get project usage stats
      *
      *
      * @param {string} startDate
      * @param {string} endDate
-     * @param {string} period
+     * @param {ProjectUsageRange} period
      * @throws {AppwriteException}
      * @returns {Promise}
     */
-    async getUsage(startDate: string, endDate: string, period?: string): Promise<Models.UsageProject> {
+    async getUsage(startDate: string, endDate: string, period?: ProjectUsageRange): Promise<Models.UsageProject> {
         if (typeof startDate === 'undefined') {
             throw new AppwriteException('Missing required parameter: "startDate"');
         }

package/src/services/projects.ts

@@ -2,6 +2,17 @@ import { Service } from '../service';
 import { AppwriteException, Client } from '../client';
 import type { Models } from '../models';
 import type { UploadProgress, Payload } from '../client';
+import { Region } from '../enums/region';
+import { Api } from '../enums/api';
+import { AuthMethod } from '../enums/auth-method';
+import { OAuthProvider } from '../enums/o-auth-provider';
+import { PlatformType } from '../enums/platform-type';
+import { ApiService } from '../enums/api-service';
+import { SMTPSecure } from '../enums/s-m-t-p-secure';
+import { EmailTemplateType } from '../enums/email-template-type';
+import { EmailTemplateLocale } from '../enums/email-template-locale';
+import { SmsTemplateType } from '../enums/sms-template-type';
+import { SmsTemplateLocale } from '../enums/sms-template-locale';
 
 export class Projects extends Service {
 
@@ -44,7 +55,7 @@ export class Projects extends Service {
      * @param {string} projectId
      * @param {string} name
      * @param {string} teamId
-     * @param {string} region
+     * @param {Region} region
      * @param {string} description
      * @param {string} logo
      * @param {string} url
@@ -57,7 +68,7 @@ export class Projects extends Service {
      * @throws {AppwriteException}
      * @returns {Promise}
     */
-    async create(projectId: string, name: string, teamId: string, region?: string, description?: string, logo?: string, url?: string, legalName?: string, legalCountry?: string, legalState?: string, legalCity?: string, legalAddress?: string, legalTaxId?: string): Promise<Models.Project> {
+    async create(projectId: string, name: string, teamId: string, region?: Region, description?: string, logo?: string, url?: string, legalName?: string, legalCountry?: string, legalState?: string, legalCity?: string, legalAddress?: string, legalTaxId?: string): Promise<Models.Project> {
         if (typeof projectId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "projectId"');
         }
@@ -252,28 +263,37 @@ export class Projects extends Service {
     }
 
     /**
-     * Update project authentication duration
+     * Update API status
      *
      *
      * @param {string} projectId
-     * @param {number} duration
+     * @param {Api} api
+     * @param {boolean} status
      * @throws {AppwriteException}
      * @returns {Promise}
     */
-    async updateAuthDuration(projectId: string, duration: number): Promise<Models.Project> {
+    async updateApiStatus(projectId: string, api: Api, status: boolean): Promise<Models.Project> {
         if (typeof projectId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "projectId"');
         }
 
-        if (typeof duration === 'undefined') {
-            throw new AppwriteException('Missing required parameter: "duration"');
+        if (typeof api === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "api"');
         }
 
-        const apiPath = '/projects/{projectId}/auth/duration'.replace('{projectId}', projectId);
+        if (typeof status === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "status"');
+        }
+
+        const apiPath = '/projects/{projectId}/api'.replace('{projectId}', projectId);
         const payload: Payload = {};
 
-        if (typeof duration !== 'undefined') {
-            payload['duration'] = duration;
+        if (typeof api !== 'undefined') {
+            payload['api'] = api;
+        }
+
+        if (typeof status !== 'undefined') {
+            payload['status'] = status;
         }
 
         const uri = new URL(this.client.config.endpoint + apiPath);
@@ -283,28 +303,28 @@ export class Projects extends Service {
     }
 
     /**
-     * Update project users limit
+     * Update all API status
      *
      *
      * @param {string} projectId
-     * @param {number} limit
+     * @param {boolean} status
      * @throws {AppwriteException}
      * @returns {Promise}
     */
-    async updateAuthLimit(projectId: string, limit: number): Promise<Models.Project> {
+    async updateApiStatusAll(projectId: string, status: boolean): Promise<Models.Project> {
         if (typeof projectId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "projectId"');
         }
 
-        if (typeof limit === 'undefined') {
-            throw new AppwriteException('Missing required parameter: "limit"');
+        if (typeof status === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "status"');
         }
 
-        const apiPath = '/projects/{projectId}/auth/limit'.replace('{projectId}', projectId);
+        const apiPath = '/projects/{projectId}/api/all'.replace('{projectId}', projectId);
         const payload: Payload = {};
 
-        if (typeof limit !== 'undefined') {
-            payload['limit'] = limit;
+        if (typeof status !== 'undefined') {
+            payload['status'] = status;
         }
 
         const uri = new URL(this.client.config.endpoint + apiPath);
@@ -314,7 +334,38 @@ export class Projects extends Service {
     }
 
     /**
-     * Update project user sessions limit
+     * Update project authentication duration
+     *
+     *
+     * @param {string} projectId
+     * @param {number} duration
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async updateAuthDuration(projectId: string, duration: number): Promise<Models.Project> {
+        if (typeof projectId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "projectId"');
+        }
+
+        if (typeof duration === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "duration"');
+        }
+
+        const apiPath = '/projects/{projectId}/auth/duration'.replace('{projectId}', projectId);
+        const payload: Payload = {};
+
+        if (typeof duration !== 'undefined') {
+            payload['duration'] = duration;
+        }
+
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        return await this.client.call('patch', uri, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Update project users limit
      *
      *
      * @param {string} projectId
@@ -322,7 +373,7 @@ export class Projects extends Service {
      * @throws {AppwriteException}
      * @returns {Promise}
     */
-    async updateAuthSessionsLimit(projectId: string, limit: number): Promise<Models.Project> {
+    async updateAuthLimit(projectId: string, limit: number): Promise<Models.Project> {
         if (typeof projectId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "projectId"');
         }
@@ -331,7 +382,7 @@ export class Projects extends Service {
             throw new AppwriteException('Missing required parameter: "limit"');
         }
 
-        const apiPath = '/projects/{projectId}/auth/max-sessions'.replace('{projectId}', projectId);
+        const apiPath = '/projects/{projectId}/auth/limit'.replace('{projectId}', projectId);
         const payload: Payload = {};
 
         if (typeof limit !== 'undefined') {
@@ -345,28 +396,28 @@ export class Projects extends Service {
     }
 
     /**
-     * Update Project user minimum sessions factors
+     * Update project user sessions limit
      *
      *
      * @param {string} projectId
-     * @param {number} factors
+     * @param {number} limit
      * @throws {AppwriteException}
      * @returns {Promise}
     */
-    async updateAuthMfaFactors(projectId: string, factors: number): Promise<Models.Project> {
+    async updateAuthSessionsLimit(projectId: string, limit: number): Promise<Models.Project> {
         if (typeof projectId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "projectId"');
         }
 
-        if (typeof factors === 'undefined') {
-            throw new AppwriteException('Missing required parameter: "factors"');
+        if (typeof limit === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "limit"');
         }
 
-        const apiPath = '/projects/{projectId}/auth/mfa/factors'.replace('{projectId}', projectId);
+        const apiPath = '/projects/{projectId}/auth/max-sessions'.replace('{projectId}', projectId);
         const payload: Payload = {};
 
-        if (typeof factors !== 'undefined') {
-            payload['factors'] = factors;
+        if (typeof limit !== 'undefined') {
+            payload['limit'] = limit;
         }
 
         const uri = new URL(this.client.config.endpoint + apiPath);
@@ -473,12 +524,12 @@ export class Projects extends Service {
      *
      *
      * @param {string} projectId
-     * @param {string} method
+     * @param {AuthMethod} method
      * @param {boolean} status
      * @throws {AppwriteException}
      * @returns {Promise}
     */
-    async updateAuthStatus(projectId: string, method: string, status: boolean): Promise<Models.Project> {
+    async updateAuthStatus(projectId: string, method: AuthMethod, status: boolean): Promise<Models.Project> {
         if (typeof projectId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "projectId"');
         }
@@ -680,14 +731,14 @@ export class Projects extends Service {
      *
      *
      * @param {string} projectId
-     * @param {string} provider
+     * @param {OAuthProvider} provider
      * @param {string} appId
      * @param {string} secret
      * @param {boolean} enabled
      * @throws {AppwriteException}
      * @returns {Promise}
     */
-    async updateOAuth2(projectId: string, provider: string, appId?: string, secret?: string, enabled?: boolean): Promise<Models.Project> {
+    async updateOAuth2(projectId: string, provider: OAuthProvider, appId?: string, secret?: string, enabled?: boolean): Promise<Models.Project> {
         if (typeof projectId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "projectId"');
         }
@@ -748,7 +799,7 @@ export class Projects extends Service {
      *
      *
      * @param {string} projectId
-     * @param {string} type
+     * @param {PlatformType} type
      * @param {string} name
      * @param {string} key
      * @param {string} store
@@ -756,7 +807,7 @@ export class Projects extends Service {
      * @throws {AppwriteException}
      * @returns {Promise}
     */
-    async createPlatform(projectId: string, type: string, name: string, key?: string, store?: string, hostname?: string): Promise<Models.Platform> {
+    async createPlatform(projectId: string, type: PlatformType, name: string, key?: string, store?: string, hostname?: string): Promise<Models.Platform> {
         if (typeof projectId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "projectId"');
         }
@@ -908,12 +959,12 @@ export class Projects extends Service {
      *
      *
      * @param {string} projectId
-     * @param {string} service
+     * @param {ApiService} service
      * @param {boolean} status
      * @throws {AppwriteException}
      * @returns {Promise}
     */
-    async updateServiceStatus(projectId: string, service: string, status: boolean): Promise<Models.Project> {
+    async updateServiceStatus(projectId: string, service: ApiService, status: boolean): Promise<Models.Project> {
         if (typeof projectId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "projectId"');
         }
@@ -987,11 +1038,11 @@ export class Projects extends Service {
      * @param {number} port
      * @param {string} username
      * @param {string} password
-     * @param {string} secure
+     * @param {SMTPSecure} secure
      * @throws {AppwriteException}
      * @returns {Promise}
     */
-    async updateSmtp(projectId: string, enabled: boolean, senderName?: string, senderEmail?: string, replyTo?: string, host?: string, port?: number, username?: string, password?: string, secure?: string): Promise<Models.Project> {
+    async updateSmtp(projectId: string, enabled: boolean, senderName?: string, senderEmail?: string, replyTo?: string, host?: string, port?: number, username?: string, password?: string, secure?: SMTPSecure): Promise<Models.Project> {
         if (typeof projectId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "projectId"');
         }
@@ -1058,11 +1109,11 @@ export class Projects extends Service {
      * @param {number} port
      * @param {string} username
      * @param {string} password
-     * @param {string} secure
+     * @param {SMTPSecure} secure
      * @throws {AppwriteException}
      * @returns {Promise}
     */
-    async createSmtpTest(projectId: string, emails: string[], senderName: string, senderEmail: string, host: string, replyTo?: string, port?: number, username?: string, password?: string, secure?: string): Promise<{}> {
+    async createSmtpTest(projectId: string, emails: string[], senderName: string, senderEmail: string, host: string, replyTo?: string, port?: number, username?: string, password?: string, secure?: SMTPSecure): Promise<{}> {
         if (typeof projectId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "projectId"');
         }
@@ -1164,12 +1215,12 @@ export class Projects extends Service {
      *
      *
      * @param {string} projectId
-     * @param {string} type
-     * @param {string} locale
+     * @param {EmailTemplateType} type
+     * @param {EmailTemplateLocale} locale
      * @throws {AppwriteException}
      * @returns {Promise}
     */
-    async getEmailTemplate(projectId: string, type: string, locale: string): Promise<Models.EmailTemplate> {
+    async getEmailTemplate(projectId: string, type: EmailTemplateType, locale: EmailTemplateLocale): Promise<Models.EmailTemplate> {
         if (typeof projectId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "projectId"');
         }
@@ -1196,8 +1247,8 @@ export class Projects extends Service {
      *
      *
      * @param {string} projectId
-     * @param {string} type
-     * @param {string} locale
+     * @param {EmailTemplateType} type
+     * @param {EmailTemplateLocale} locale
      * @param {string} subject
      * @param {string} message
      * @param {string} senderName
@@ -1206,7 +1257,7 @@ export class Projects extends Service {
      * @throws {AppwriteException}
      * @returns {Promise}
     */
-    async updateEmailTemplate(projectId: string, type: string, locale: string, subject: string, message: string, senderName?: string, senderEmail?: string, replyTo?: string): Promise<Models.Project> {
+    async updateEmailTemplate(projectId: string, type: EmailTemplateType, locale: EmailTemplateLocale, subject: string, message: string, senderName?: string, senderEmail?: string, replyTo?: string): Promise<Models.Project> {
         if (typeof projectId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "projectId"');
         }
@@ -1261,12 +1312,12 @@ export class Projects extends Service {
      *
      *
      * @param {string} projectId
-     * @param {string} type
-     * @param {string} locale
+     * @param {EmailTemplateType} type
+     * @param {EmailTemplateLocale} locale
      * @throws {AppwriteException}
      * @returns {Promise}
     */
-    async deleteEmailTemplate(projectId: string, type: string, locale: string): Promise<Models.EmailTemplate> {
+    async deleteEmailTemplate(projectId: string, type: EmailTemplateType, locale: EmailTemplateLocale): Promise<Models.EmailTemplate> {
         if (typeof projectId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "projectId"');
         }
@@ -1293,12 +1344,12 @@ export class Projects extends Service {
      *
      *
      * @param {string} projectId
-     * @param {string} type
-     * @param {string} locale
+     * @param {SmsTemplateType} type
+     * @param {SmsTemplateLocale} locale
      * @throws {AppwriteException}
      * @returns {Promise}
     */
-    async getSmsTemplate(projectId: string, type: string, locale: string): Promise<Models.SmsTemplate> {
+    async getSmsTemplate(projectId: string, type: SmsTemplateType, locale: SmsTemplateLocale): Promise<Models.SmsTemplate> {
         if (typeof projectId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "projectId"');
         }
@@ -1325,13 +1376,13 @@ export class Projects extends Service {
      *
      *
      * @param {string} projectId
-     * @param {string} type
-     * @param {string} locale
+     * @param {SmsTemplateType} type
+     * @param {SmsTemplateLocale} locale
      * @param {string} message
      * @throws {AppwriteException}
      * @returns {Promise}
     */
-    async updateSmsTemplate(projectId: string, type: string, locale: string, message: string): Promise<Models.SmsTemplate> {
+    async updateSmsTemplate(projectId: string, type: SmsTemplateType, locale: SmsTemplateLocale, message: string): Promise<Models.SmsTemplate> {
         if (typeof projectId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "projectId"');
         }
@@ -1366,12 +1417,12 @@ export class Projects extends Service {
      *
      *
      * @param {string} projectId
-     * @param {string} type
-     * @param {string} locale
+     * @param {SmsTemplateType} type
+     * @param {SmsTemplateLocale} locale
      * @throws {AppwriteException}
      * @returns {Promise}
     */
-    async deleteSmsTemplate(projectId: string, type: string, locale: string): Promise<Models.SmsTemplate> {
+    async deleteSmsTemplate(projectId: string, type: SmsTemplateType, locale: SmsTemplateLocale): Promise<Models.SmsTemplate> {
         if (typeof projectId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "projectId"');
         }

package/src/services/proxy.ts

@@ -2,6 +2,7 @@ import { Service } from '../service';
 import { AppwriteException, Client } from '../client';
 import type { Models } from '../models';
 import type { UploadProgress, Payload } from '../client';
+import { ResourceType } from '../enums/resource-type';
 
 export class Proxy extends Service {
 
@@ -45,12 +46,12 @@ export class Proxy extends Service {
      * Create a new proxy rule.
      *
      * @param {string} domain
-     * @param {string} resourceType
+     * @param {ResourceType} resourceType
      * @param {string} resourceId
      * @throws {AppwriteException}
      * @returns {Promise}
     */
-    async createRule(domain: string, resourceType: string, resourceId?: string): Promise<Models.ProxyRule> {
+    async createRule(domain: string, resourceType: ResourceType, resourceId?: string): Promise<Models.ProxyRule> {
         if (typeof domain === 'undefined') {
             throw new AppwriteException('Missing required parameter: "domain"');
         }

package/src/services/storage.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 { Compression } from '../enums/compression';
+import { ImageGravity } from '../enums/image-gravity';
+import { ImageFormat } from '../enums/image-format';
+import { StorageUsageRange } from '../enums/storage-usage-range';
 
 export class Storage extends Service {
 
@@ -51,13 +55,13 @@ export class Storage extends Service {
      * @param {boolean} enabled
      * @param {number} maximumFileSize
      * @param {string[]} allowedFileExtensions
-     * @param {string} compression
+     * @param {Compression} compression
      * @param {boolean} encryption
      * @param {boolean} antivirus
      * @throws {AppwriteException}
      * @returns {Promise}
     */
-    async createBucket(bucketId: string, name: string, permissions?: string[], fileSecurity?: boolean, enabled?: boolean, maximumFileSize?: number, allowedFileExtensions?: string[], compression?: string, encryption?: boolean, antivirus?: boolean): Promise<Models.Bucket> {
+    async createBucket(bucketId: string, name: string, permissions?: string[], fileSecurity?: boolean, enabled?: boolean, maximumFileSize?: number, allowedFileExtensions?: string[], compression?: Compression, encryption?: boolean, antivirus?: boolean): Promise<Models.Bucket> {
         if (typeof bucketId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "bucketId"');
         }
@@ -151,13 +155,13 @@ export class Storage extends Service {
      * @param {boolean} enabled
      * @param {number} maximumFileSize
      * @param {string[]} allowedFileExtensions
-     * @param {string} compression
+     * @param {Compression} compression
      * @param {boolean} encryption
      * @param {boolean} antivirus
      * @throws {AppwriteException}
      * @returns {Promise}
     */
-    async updateBucket(bucketId: string, name: string, permissions?: string[], fileSecurity?: boolean, enabled?: boolean, maximumFileSize?: number, allowedFileExtensions?: string[], compression?: string, encryption?: boolean, antivirus?: boolean): Promise<Models.Bucket> {
+    async updateBucket(bucketId: string, name: string, permissions?: string[], fileSecurity?: boolean, enabled?: boolean, maximumFileSize?: number, allowedFileExtensions?: string[], compression?: Compression, encryption?: boolean, antivirus?: boolean): Promise<Models.Bucket> {
         if (typeof bucketId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "bucketId"');
         }
@@ -523,7 +527,7 @@ export class Storage extends Service {
      * @param {string} fileId
      * @param {number} width
      * @param {number} height
-     * @param {string} gravity
+     * @param {ImageGravity} gravity
      * @param {number} quality
      * @param {number} borderWidth
      * @param {string} borderColor
@@ -531,11 +535,11 @@ export class Storage extends Service {
      * @param {number} opacity
      * @param {number} rotation
      * @param {string} background
-     * @param {string} output
+     * @param {ImageFormat} output
      * @throws {AppwriteException}
      * @returns {URL}
     */
-    getFilePreview(bucketId: string, fileId: string, width?: number, height?: number, gravity?: string, quality?: number, borderWidth?: number, borderColor?: string, borderRadius?: number, opacity?: number, rotation?: number, background?: string, output?: string): URL {
+    getFilePreview(bucketId: string, fileId: string, width?: number, height?: number, gravity?: ImageGravity, quality?: number, borderWidth?: number, borderColor?: string, borderRadius?: number, opacity?: number, rotation?: number, background?: string, output?: ImageFormat): URL {
         if (typeof bucketId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "bucketId"');
         }
@@ -636,14 +640,14 @@ export class Storage extends Service {
     }
 
     /**
-     * Get usage stats for storage
+     * Get storage usage stats
      *
      *
-     * @param {string} range
+     * @param {StorageUsageRange} range
      * @throws {AppwriteException}
      * @returns {Promise}
     */
-    async getUsage(range?: string): Promise<Models.UsageStorage> {
+    async getUsage(range?: StorageUsageRange): Promise<Models.UsageStorage> {
         const apiPath = '/storage/usage';
         const payload: Payload = {};
 
@@ -658,15 +662,15 @@ export class Storage extends Service {
     }
 
     /**
-     * Get usage stats for storage bucket
+     * Get bucket usage stats
      *
      *
      * @param {string} bucketId
-     * @param {string} range
+     * @param {StorageUsageRange} range
      * @throws {AppwriteException}
      * @returns {Promise}
     */
-    async getBucketUsage(bucketId: string, range?: string): Promise<Models.UsageBuckets> {
+    async getBucketUsage(bucketId: string, range?: StorageUsageRange): Promise<Models.UsageBuckets> {
         if (typeof bucketId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "bucketId"');
         }