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

package/src/services/migrations.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 { Query } from '../query';
 
 export class Migrations extends Service {
 
@@ -14,12 +15,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,8 @@ 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 { ProjectUsageRange } from '../enums/project-usage-range';
 
 export class Project extends Service {
 
@@ -16,11 +18,11 @@ export class Project extends Service {
      *
      * @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 { Query } from '../query';
+import { Region } from '../enums/region';
+import { AuthMethod } from '../enums/auth-method';
+import { OAuthProvider } from '../enums/o-auth-provider';
+import { PlatformType } from '../enums/platform-type';
+import { APIService } from '../enums/a-p-i-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/s-m-s-template-type';
+import { SMSTemplateLocale } from '../enums/s-m-s-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"');
         }
@@ -442,12 +453,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"');
         }
@@ -649,14 +660,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"');
         }
@@ -717,7 +728,7 @@ export class Projects extends Service {
      *
      *
      * @param {string} projectId
-     * @param {string} type
+     * @param {PlatformType} type
      * @param {string} name
      * @param {string} key
      * @param {string} store
@@ -725,7 +736,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"');
         }
@@ -877,12 +888,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"');
         }
@@ -944,7 +955,7 @@ export class Projects extends Service {
     }
 
     /**
-     * Update SMTP configuration
+     * Update SMTP
      *
      *
      * @param {string} projectId
@@ -956,11 +967,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 updateSmtpConfiguration(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"');
         }
@@ -1014,6 +1025,89 @@ export class Projects extends Service {
         }, payload);
     }
 
+    /**
+     * Create SMTP test
+     *
+     *
+     * @param {string} projectId
+     * @param {string[]} emails
+     * @param {string} senderName
+     * @param {string} senderEmail
+     * @param {string} host
+     * @param {string} replyTo
+     * @param {number} port
+     * @param {string} username
+     * @param {string} password
+     * @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?: SMTPSecure): Promise<{}> {
+        if (typeof projectId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "projectId"');
+        }
+
+        if (typeof emails === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "emails"');
+        }
+
+        if (typeof senderName === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "senderName"');
+        }
+
+        if (typeof senderEmail === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "senderEmail"');
+        }
+
+        if (typeof host === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "host"');
+        }
+
+        const apiPath = '/projects/{projectId}/smtp/tests'.replace('{projectId}', projectId);
+        const payload: Payload = {};
+
+        if (typeof emails !== 'undefined') {
+            payload['emails'] = emails;
+        }
+
+        if (typeof senderName !== 'undefined') {
+            payload['senderName'] = senderName;
+        }
+
+        if (typeof senderEmail !== 'undefined') {
+            payload['senderEmail'] = senderEmail;
+        }
+
+        if (typeof replyTo !== 'undefined') {
+            payload['replyTo'] = replyTo;
+        }
+
+        if (typeof host !== 'undefined') {
+            payload['host'] = host;
+        }
+
+        if (typeof port !== 'undefined') {
+            payload['port'] = port;
+        }
+
+        if (typeof username !== 'undefined') {
+            payload['username'] = username;
+        }
+
+        if (typeof password !== 'undefined') {
+            payload['password'] = password;
+        }
+
+        if (typeof secure !== 'undefined') {
+            payload['secure'] = secure;
+        }
+
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        return await this.client.call('post', uri, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
     /**
      * Update Project Team
      *
@@ -1050,12 +1144,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"');
         }
@@ -1082,8 +1176,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
@@ -1092,7 +1186,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"');
         }
@@ -1147,12 +1241,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"');
         }
@@ -1179,12 +1273,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"');
         }
@@ -1211,13 +1305,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"');
         }
@@ -1252,12 +1346,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"');
         }
@@ -1310,12 +1404,13 @@ export class Projects extends Service {
      * @param {string[]} events
      * @param {string} url
      * @param {boolean} security
+     * @param {boolean} enabled
      * @param {string} httpUser
      * @param {string} httpPass
      * @throws {AppwriteException}
      * @returns {Promise}
     */
-    async createWebhook(projectId: string, name: string, events: string[], url: string, security: boolean, httpUser?: string, httpPass?: string): Promise<Models.Webhook> {
+    async createWebhook(projectId: string, name: string, events: string[], url: string, security: boolean, enabled?: boolean, httpUser?: string, httpPass?: string): Promise<Models.Webhook> {
         if (typeof projectId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "projectId"');
         }
@@ -1343,6 +1438,10 @@ export class Projects extends Service {
             payload['name'] = name;
         }
 
+        if (typeof enabled !== 'undefined') {
+            payload['enabled'] = enabled;
+        }
+
         if (typeof events !== 'undefined') {
             payload['events'] = events;
         }
@@ -1406,12 +1505,13 @@ export class Projects extends Service {
      * @param {string[]} events
      * @param {string} url
      * @param {boolean} security
+     * @param {boolean} enabled
      * @param {string} httpUser
      * @param {string} httpPass
      * @throws {AppwriteException}
      * @returns {Promise}
     */
-    async updateWebhook(projectId: string, webhookId: string, name: string, events: string[], url: string, security: boolean, httpUser?: string, httpPass?: string): Promise<Models.Webhook> {
+    async updateWebhook(projectId: string, webhookId: string, name: string, events: string[], url: string, security: boolean, enabled?: boolean, httpUser?: string, httpPass?: string): Promise<Models.Webhook> {
         if (typeof projectId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "projectId"');
         }
@@ -1443,6 +1543,10 @@ export class Projects extends Service {
             payload['name'] = name;
         }
 
+        if (typeof enabled !== 'undefined') {
+            payload['enabled'] = enabled;
+        }
+
         if (typeof events !== 'undefined') {
             payload['events'] = events;
         }

package/src/services/proxy.ts

@@ -2,6 +2,8 @@ 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 { ResourceType } from '../enums/resource-type';
 
 export class Proxy extends Service {
 
@@ -45,12 +47,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,11 @@ 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 { 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 +56,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 +156,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 +528,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 +536,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"');
         }
@@ -639,11 +644,11 @@ export class Storage extends Service {
      * Get usage stats for storage
      *
      *
-     * @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 = {};
 
@@ -662,11 +667,11 @@ export class Storage extends Service {
      *
      *
      * @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"');
         }

package/src/services/teams.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 { Query } from '../query';
 
 export class Teams extends Service {