@appwrite.io/console 2.2.0 → 2.3.1

package/src/services/backups.ts

@@ -2,7 +2,7 @@ import { Service } from '../service';
 import { AppwriteException, Client, type Payload, UploadProgress } from '../client';
 import type { Models } from '../models';
 
-import { Services } from '../enums/services';
+import { BackupServices } from '../enums/backup-services';
 
 export class Backups {
     client: Client;
@@ -65,33 +65,33 @@ export class Backups {
     /**
      * Create a new archive asynchronously for a project.
      *
-     * @param {Services[]} params.services - Array of services to backup
+     * @param {BackupServices[]} params.services - Array of services to backup
      * @param {string} params.resourceId - Resource ID. When set, only this single resource will be backed up.
      * @throws {AppwriteException}
      * @returns {Promise<Models.BackupArchive>}
      */
-    createArchive(params: { services: Services[], resourceId?: string }): Promise<Models.BackupArchive>;
+    createArchive(params: { services: BackupServices[], resourceId?: string }): Promise<Models.BackupArchive>;
     /**
      * Create a new archive asynchronously for a project.
      *
-     * @param {Services[]} services - Array of services to backup
+     * @param {BackupServices[]} services - Array of services to backup
      * @param {string} resourceId - Resource ID. When set, only this single resource will be backed up.
      * @throws {AppwriteException}
      * @returns {Promise<Models.BackupArchive>}
      * @deprecated Use the object parameter style method for a better developer experience.
      */
-    createArchive(services: Services[], resourceId?: string): Promise<Models.BackupArchive>;
+    createArchive(services: BackupServices[], resourceId?: string): Promise<Models.BackupArchive>;
     createArchive(
-        paramsOrFirst: { services: Services[], resourceId?: string } | Services[],
+        paramsOrFirst: { services: BackupServices[], resourceId?: string } | BackupServices[],
         ...rest: [(string)?]    
     ): Promise<Models.BackupArchive> {
-        let params: { services: Services[], resourceId?: string };
+        let params: { services: BackupServices[], resourceId?: string };
         
-        if ((paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst) && 'services' in paramsOrFirst)) {
-            params = (paramsOrFirst || {}) as { services: Services[], resourceId?: string };
+        if ((paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst) && ('services' in paramsOrFirst || 'resourceId' in paramsOrFirst))) {
+            params = (paramsOrFirst || {}) as { services: BackupServices[], resourceId?: string };
         } else {
             params = {
-                services: paramsOrFirst as Services[],
+                services: paramsOrFirst as BackupServices[],
                 resourceId: rest[0] as string            
             };
         }
@@ -283,7 +283,7 @@ export class Backups {
      * Create a new backup policy.
      *
      * @param {string} params.policyId - Policy ID. Choose a custom ID or generate a random ID with `ID.unique()`. Valid chars are a-z, A-Z, 0-9, period, hyphen, and underscore. Can't start with a special char. Max length is 36 chars.
-     * @param {Services[]} params.services - Array of services to backup
+     * @param {BackupServices[]} params.services - Array of services to backup
      * @param {number} params.retention - Days to keep backups before deletion
      * @param {string} params.schedule - Schedule CRON syntax.
      * @param {string} params.name - Policy name. Max length: 128 chars.
@@ -292,12 +292,12 @@ export class Backups {
      * @throws {AppwriteException}
      * @returns {Promise<Models.BackupPolicy>}
      */
-    createPolicy(params: { policyId: string, services: Services[], retention: number, schedule: string, name?: string, resourceId?: string, enabled?: boolean }): Promise<Models.BackupPolicy>;
+    createPolicy(params: { policyId: string, services: BackupServices[], retention: number, schedule: string, name?: string, resourceId?: string, enabled?: boolean }): Promise<Models.BackupPolicy>;
     /**
      * Create a new backup policy.
      *
      * @param {string} policyId - Policy ID. Choose a custom ID or generate a random ID with `ID.unique()`. Valid chars are a-z, A-Z, 0-9, period, hyphen, and underscore. Can't start with a special char. Max length is 36 chars.
-     * @param {Services[]} services - Array of services to backup
+     * @param {BackupServices[]} services - Array of services to backup
      * @param {number} retention - Days to keep backups before deletion
      * @param {string} schedule - Schedule CRON syntax.
      * @param {string} name - Policy name. Max length: 128 chars.
@@ -307,19 +307,19 @@ export class Backups {
      * @returns {Promise<Models.BackupPolicy>}
      * @deprecated Use the object parameter style method for a better developer experience.
      */
-    createPolicy(policyId: string, services: Services[], retention: number, schedule: string, name?: string, resourceId?: string, enabled?: boolean): Promise<Models.BackupPolicy>;
+    createPolicy(policyId: string, services: BackupServices[], retention: number, schedule: string, name?: string, resourceId?: string, enabled?: boolean): Promise<Models.BackupPolicy>;
     createPolicy(
-        paramsOrFirst: { policyId: string, services: Services[], retention: number, schedule: string, name?: string, resourceId?: string, enabled?: boolean } | string,
-        ...rest: [(Services[])?, (number)?, (string)?, (string)?, (string)?, (boolean)?]    
+        paramsOrFirst: { policyId: string, services: BackupServices[], retention: number, schedule: string, name?: string, resourceId?: string, enabled?: boolean } | string,
+        ...rest: [(BackupServices[])?, (number)?, (string)?, (string)?, (string)?, (boolean)?]    
     ): Promise<Models.BackupPolicy> {
-        let params: { policyId: string, services: Services[], retention: number, schedule: string, name?: string, resourceId?: string, enabled?: boolean };
+        let params: { policyId: string, services: BackupServices[], retention: number, schedule: string, name?: string, resourceId?: string, enabled?: boolean };
         
         if ((paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst))) {
-            params = (paramsOrFirst || {}) as { policyId: string, services: Services[], retention: number, schedule: string, name?: string, resourceId?: string, enabled?: boolean };
+            params = (paramsOrFirst || {}) as { policyId: string, services: BackupServices[], retention: number, schedule: string, name?: string, resourceId?: string, enabled?: boolean };
         } else {
             params = {
                 policyId: paramsOrFirst as string,
-                services: rest[0] as Services[],
+                services: rest[0] as BackupServices[],
                 retention: rest[1] as number,
                 schedule: rest[2] as string,
                 name: rest[3] as string,
@@ -574,37 +574,37 @@ export class Backups {
      * Create and trigger a new restoration for a backup on a project.
      *
      * @param {string} params.archiveId - Backup archive ID to restore
-     * @param {Services[]} params.services - Array of services to restore
+     * @param {BackupServices[]} params.services - Array of services to restore
      * @param {string} params.newResourceId - Unique Id. Choose a custom ID or generate a random ID with `ID.unique()`. Valid chars are a-z, A-Z, 0-9, period, hyphen, and underscore. Can't start with a special char. Max length is 36 chars.
      * @param {string} params.newResourceName - Database name. Max length: 128 chars.
      * @throws {AppwriteException}
      * @returns {Promise<Models.BackupRestoration>}
      */
-    createRestoration(params: { archiveId: string, services: Services[], newResourceId?: string, newResourceName?: string }): Promise<Models.BackupRestoration>;
+    createRestoration(params: { archiveId: string, services: BackupServices[], newResourceId?: string, newResourceName?: string }): Promise<Models.BackupRestoration>;
     /**
      * Create and trigger a new restoration for a backup on a project.
      *
      * @param {string} archiveId - Backup archive ID to restore
-     * @param {Services[]} services - Array of services to restore
+     * @param {BackupServices[]} services - Array of services to restore
      * @param {string} newResourceId - Unique Id. Choose a custom ID or generate a random ID with `ID.unique()`. Valid chars are a-z, A-Z, 0-9, period, hyphen, and underscore. Can't start with a special char. Max length is 36 chars.
      * @param {string} newResourceName - Database name. Max length: 128 chars.
      * @throws {AppwriteException}
      * @returns {Promise<Models.BackupRestoration>}
      * @deprecated Use the object parameter style method for a better developer experience.
      */
-    createRestoration(archiveId: string, services: Services[], newResourceId?: string, newResourceName?: string): Promise<Models.BackupRestoration>;
+    createRestoration(archiveId: string, services: BackupServices[], newResourceId?: string, newResourceName?: string): Promise<Models.BackupRestoration>;
     createRestoration(
-        paramsOrFirst: { archiveId: string, services: Services[], newResourceId?: string, newResourceName?: string } | string,
-        ...rest: [(Services[])?, (string)?, (string)?]    
+        paramsOrFirst: { archiveId: string, services: BackupServices[], newResourceId?: string, newResourceName?: string } | string,
+        ...rest: [(BackupServices[])?, (string)?, (string)?]    
     ): Promise<Models.BackupRestoration> {
-        let params: { archiveId: string, services: Services[], newResourceId?: string, newResourceName?: string };
+        let params: { archiveId: string, services: BackupServices[], newResourceId?: string, newResourceName?: string };
         
         if ((paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst))) {
-            params = (paramsOrFirst || {}) as { archiveId: string, services: Services[], newResourceId?: string, newResourceName?: string };
+            params = (paramsOrFirst || {}) as { archiveId: string, services: BackupServices[], newResourceId?: string, newResourceName?: string };
         } else {
             params = {
                 archiveId: paramsOrFirst as string,
-                services: rest[0] as Services[],
+                services: rest[0] as BackupServices[],
                 newResourceId: rest[1] as string,
                 newResourceName: rest[2] as string            
             };

package/src/services/console.ts

@@ -136,7 +136,7 @@ export class Console {
     ): Promise<Models.BillingPlanList> {
         let params: { platform?: Platform };
         
-        if (!paramsOrFirst || (paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst) && 'platform' in paramsOrFirst)) {
+        if (!paramsOrFirst || (paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst) && ('platform' in paramsOrFirst))) {
             params = (paramsOrFirst || {}) as { platform?: Platform };
         } else {
             params = {

package/src/services/databases.ts

@@ -514,7 +514,7 @@ export class Databases {
     ): Promise<Models.UsageDatabases> {
         let params: { range?: UsageRange };
         
-        if (!paramsOrFirst || (paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst) && 'range' in paramsOrFirst)) {
+        if (!paramsOrFirst || (paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst) && ('range' in paramsOrFirst))) {
             params = (paramsOrFirst || {}) as { range?: UsageRange };
         } else {
             params = {
@@ -2801,10 +2801,11 @@ export class Databases {
      * @param {boolean} params.required - Is attribute required?
      * @param {string} params.xdefault - Default value for attribute when not provided. Cannot be set when attribute is required.
      * @param {boolean} params.array - Is attribute an array?
+     * @param {boolean} params.encrypt - Toggle encryption for the attribute. Encryption enhances security by not storing any plain text values in the database. However, encrypted attributes cannot be queried.
      * @throws {AppwriteException}
      * @returns {Promise<Models.AttributeLongtext>}
      */
-    createLongtextAttribute(params: { databaseId: string, collectionId: string, key: string, required: boolean, xdefault?: string, array?: boolean }): Promise<Models.AttributeLongtext>;
+    createLongtextAttribute(params: { databaseId: string, collectionId: string, key: string, required: boolean, xdefault?: string, array?: boolean, encrypt?: boolean }): Promise<Models.AttributeLongtext>;
     /**
      * Create a longtext attribute.
      * 
@@ -2815,19 +2816,20 @@ export class Databases {
      * @param {boolean} required - Is attribute required?
      * @param {string} xdefault - Default value for attribute when not provided. Cannot be set when attribute is required.
      * @param {boolean} array - Is attribute an array?
+     * @param {boolean} encrypt - Toggle encryption for the attribute. Encryption enhances security by not storing any plain text values in the database. However, encrypted attributes cannot be queried.
      * @throws {AppwriteException}
      * @returns {Promise<Models.AttributeLongtext>}
      * @deprecated Use the object parameter style method for a better developer experience.
      */
-    createLongtextAttribute(databaseId: string, collectionId: string, key: string, required: boolean, xdefault?: string, array?: boolean): Promise<Models.AttributeLongtext>;
+    createLongtextAttribute(databaseId: string, collectionId: string, key: string, required: boolean, xdefault?: string, array?: boolean, encrypt?: boolean): Promise<Models.AttributeLongtext>;
     createLongtextAttribute(
-        paramsOrFirst: { databaseId: string, collectionId: string, key: string, required: boolean, xdefault?: string, array?: boolean } | string,
-        ...rest: [(string)?, (string)?, (boolean)?, (string)?, (boolean)?]    
+        paramsOrFirst: { databaseId: string, collectionId: string, key: string, required: boolean, xdefault?: string, array?: boolean, encrypt?: boolean } | string,
+        ...rest: [(string)?, (string)?, (boolean)?, (string)?, (boolean)?, (boolean)?]    
     ): Promise<Models.AttributeLongtext> {
-        let params: { databaseId: string, collectionId: string, key: string, required: boolean, xdefault?: string, array?: boolean };
+        let params: { databaseId: string, collectionId: string, key: string, required: boolean, xdefault?: string, array?: boolean, encrypt?: boolean };
         
         if ((paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst))) {
-            params = (paramsOrFirst || {}) as { databaseId: string, collectionId: string, key: string, required: boolean, xdefault?: string, array?: boolean };
+            params = (paramsOrFirst || {}) as { databaseId: string, collectionId: string, key: string, required: boolean, xdefault?: string, array?: boolean, encrypt?: boolean };
         } else {
             params = {
                 databaseId: paramsOrFirst as string,
@@ -2835,7 +2837,8 @@ export class Databases {
                 key: rest[1] as string,
                 required: rest[2] as boolean,
                 xdefault: rest[3] as string,
-                array: rest[4] as boolean            
+                array: rest[4] as boolean,
+                encrypt: rest[5] as boolean            
             };
         }
         
@@ -2845,6 +2848,7 @@ export class Databases {
         const required = params.required;
         const xdefault = params.xdefault;
         const array = params.array;
+        const encrypt = params.encrypt;
 
         if (typeof databaseId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "databaseId"');
@@ -2873,6 +2877,9 @@ export class Databases {
         if (typeof array !== 'undefined') {
             payload['array'] = array;
         }
+        if (typeof encrypt !== 'undefined') {
+            payload['encrypt'] = encrypt;
+        }
         const uri = new URL(this.client.config.endpoint + apiPath);
 
         const apiHeaders: { [header: string]: string } = {
@@ -2993,10 +3000,11 @@ export class Databases {
      * @param {boolean} params.required - Is attribute required?
      * @param {string} params.xdefault - Default value for attribute when not provided. Cannot be set when attribute is required.
      * @param {boolean} params.array - Is attribute an array?
+     * @param {boolean} params.encrypt - Toggle encryption for the attribute. Encryption enhances security by not storing any plain text values in the database. However, encrypted attributes cannot be queried.
      * @throws {AppwriteException}
      * @returns {Promise<Models.AttributeMediumtext>}
      */
-    createMediumtextAttribute(params: { databaseId: string, collectionId: string, key: string, required: boolean, xdefault?: string, array?: boolean }): Promise<Models.AttributeMediumtext>;
+    createMediumtextAttribute(params: { databaseId: string, collectionId: string, key: string, required: boolean, xdefault?: string, array?: boolean, encrypt?: boolean }): Promise<Models.AttributeMediumtext>;
     /**
      * Create a mediumtext attribute.
      * 
@@ -3007,19 +3015,20 @@ export class Databases {
      * @param {boolean} required - Is attribute required?
      * @param {string} xdefault - Default value for attribute when not provided. Cannot be set when attribute is required.
      * @param {boolean} array - Is attribute an array?
+     * @param {boolean} encrypt - Toggle encryption for the attribute. Encryption enhances security by not storing any plain text values in the database. However, encrypted attributes cannot be queried.
      * @throws {AppwriteException}
      * @returns {Promise<Models.AttributeMediumtext>}
      * @deprecated Use the object parameter style method for a better developer experience.
      */
-    createMediumtextAttribute(databaseId: string, collectionId: string, key: string, required: boolean, xdefault?: string, array?: boolean): Promise<Models.AttributeMediumtext>;
+    createMediumtextAttribute(databaseId: string, collectionId: string, key: string, required: boolean, xdefault?: string, array?: boolean, encrypt?: boolean): Promise<Models.AttributeMediumtext>;
     createMediumtextAttribute(
-        paramsOrFirst: { databaseId: string, collectionId: string, key: string, required: boolean, xdefault?: string, array?: boolean } | string,
-        ...rest: [(string)?, (string)?, (boolean)?, (string)?, (boolean)?]    
+        paramsOrFirst: { databaseId: string, collectionId: string, key: string, required: boolean, xdefault?: string, array?: boolean, encrypt?: boolean } | string,
+        ...rest: [(string)?, (string)?, (boolean)?, (string)?, (boolean)?, (boolean)?]    
     ): Promise<Models.AttributeMediumtext> {
-        let params: { databaseId: string, collectionId: string, key: string, required: boolean, xdefault?: string, array?: boolean };
+        let params: { databaseId: string, collectionId: string, key: string, required: boolean, xdefault?: string, array?: boolean, encrypt?: boolean };
         
         if ((paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst))) {
-            params = (paramsOrFirst || {}) as { databaseId: string, collectionId: string, key: string, required: boolean, xdefault?: string, array?: boolean };
+            params = (paramsOrFirst || {}) as { databaseId: string, collectionId: string, key: string, required: boolean, xdefault?: string, array?: boolean, encrypt?: boolean };
         } else {
             params = {
                 databaseId: paramsOrFirst as string,
@@ -3027,7 +3036,8 @@ export class Databases {
                 key: rest[1] as string,
                 required: rest[2] as boolean,
                 xdefault: rest[3] as string,
-                array: rest[4] as boolean            
+                array: rest[4] as boolean,
+                encrypt: rest[5] as boolean            
             };
         }
         
@@ -3037,6 +3047,7 @@ export class Databases {
         const required = params.required;
         const xdefault = params.xdefault;
         const array = params.array;
+        const encrypt = params.encrypt;
 
         if (typeof databaseId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "databaseId"');
@@ -3065,6 +3076,9 @@ export class Databases {
         if (typeof array !== 'undefined') {
             payload['array'] = array;
         }
+        if (typeof encrypt !== 'undefined') {
+            payload['encrypt'] = encrypt;
+        }
         const uri = new URL(this.client.config.endpoint + apiPath);
 
         const apiHeaders: { [header: string]: string } = {
@@ -3874,10 +3888,11 @@ export class Databases {
      * @param {boolean} params.required - Is attribute required?
      * @param {string} params.xdefault - Default value for attribute when not provided. Cannot be set when attribute is required.
      * @param {boolean} params.array - Is attribute an array?
+     * @param {boolean} params.encrypt - Toggle encryption for the attribute. Encryption enhances security by not storing any plain text values in the database. However, encrypted attributes cannot be queried.
      * @throws {AppwriteException}
      * @returns {Promise<Models.AttributeText>}
      */
-    createTextAttribute(params: { databaseId: string, collectionId: string, key: string, required: boolean, xdefault?: string, array?: boolean }): Promise<Models.AttributeText>;
+    createTextAttribute(params: { databaseId: string, collectionId: string, key: string, required: boolean, xdefault?: string, array?: boolean, encrypt?: boolean }): Promise<Models.AttributeText>;
     /**
      * Create a text attribute.
      * 
@@ -3888,19 +3903,20 @@ export class Databases {
      * @param {boolean} required - Is attribute required?
      * @param {string} xdefault - Default value for attribute when not provided. Cannot be set when attribute is required.
      * @param {boolean} array - Is attribute an array?
+     * @param {boolean} encrypt - Toggle encryption for the attribute. Encryption enhances security by not storing any plain text values in the database. However, encrypted attributes cannot be queried.
      * @throws {AppwriteException}
      * @returns {Promise<Models.AttributeText>}
      * @deprecated Use the object parameter style method for a better developer experience.
      */
-    createTextAttribute(databaseId: string, collectionId: string, key: string, required: boolean, xdefault?: string, array?: boolean): Promise<Models.AttributeText>;
+    createTextAttribute(databaseId: string, collectionId: string, key: string, required: boolean, xdefault?: string, array?: boolean, encrypt?: boolean): Promise<Models.AttributeText>;
     createTextAttribute(
-        paramsOrFirst: { databaseId: string, collectionId: string, key: string, required: boolean, xdefault?: string, array?: boolean } | string,
-        ...rest: [(string)?, (string)?, (boolean)?, (string)?, (boolean)?]    
+        paramsOrFirst: { databaseId: string, collectionId: string, key: string, required: boolean, xdefault?: string, array?: boolean, encrypt?: boolean } | string,
+        ...rest: [(string)?, (string)?, (boolean)?, (string)?, (boolean)?, (boolean)?]    
     ): Promise<Models.AttributeText> {
-        let params: { databaseId: string, collectionId: string, key: string, required: boolean, xdefault?: string, array?: boolean };
+        let params: { databaseId: string, collectionId: string, key: string, required: boolean, xdefault?: string, array?: boolean, encrypt?: boolean };
         
         if ((paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst))) {
-            params = (paramsOrFirst || {}) as { databaseId: string, collectionId: string, key: string, required: boolean, xdefault?: string, array?: boolean };
+            params = (paramsOrFirst || {}) as { databaseId: string, collectionId: string, key: string, required: boolean, xdefault?: string, array?: boolean, encrypt?: boolean };
         } else {
             params = {
                 databaseId: paramsOrFirst as string,
@@ -3908,7 +3924,8 @@ export class Databases {
                 key: rest[1] as string,
                 required: rest[2] as boolean,
                 xdefault: rest[3] as string,
-                array: rest[4] as boolean            
+                array: rest[4] as boolean,
+                encrypt: rest[5] as boolean            
             };
         }
         
@@ -3918,6 +3935,7 @@ export class Databases {
         const required = params.required;
         const xdefault = params.xdefault;
         const array = params.array;
+        const encrypt = params.encrypt;
 
         if (typeof databaseId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "databaseId"');
@@ -3946,6 +3964,9 @@ export class Databases {
         if (typeof array !== 'undefined') {
             payload['array'] = array;
         }
+        if (typeof encrypt !== 'undefined') {
+            payload['encrypt'] = encrypt;
+        }
         const uri = new URL(this.client.config.endpoint + apiPath);
 
         const apiHeaders: { [header: string]: string } = {
@@ -4261,10 +4282,11 @@ export class Databases {
      * @param {boolean} params.required - Is attribute required?
      * @param {string} params.xdefault - Default value for attribute when not provided. Cannot be set when attribute is required.
      * @param {boolean} params.array - Is attribute an array?
+     * @param {boolean} params.encrypt - Toggle encryption for the attribute. Encryption enhances security by not storing any plain text values in the database. However, encrypted attributes cannot be queried.
      * @throws {AppwriteException}
      * @returns {Promise<Models.AttributeVarchar>}
      */
-    createVarcharAttribute(params: { databaseId: string, collectionId: string, key: string, size: number, required: boolean, xdefault?: string, array?: boolean }): Promise<Models.AttributeVarchar>;
+    createVarcharAttribute(params: { databaseId: string, collectionId: string, key: string, size: number, required: boolean, xdefault?: string, array?: boolean, encrypt?: boolean }): Promise<Models.AttributeVarchar>;
     /**
      * Create a varchar attribute.
      * 
@@ -4276,19 +4298,20 @@ export class Databases {
      * @param {boolean} required - Is attribute required?
      * @param {string} xdefault - Default value for attribute when not provided. Cannot be set when attribute is required.
      * @param {boolean} array - Is attribute an array?
+     * @param {boolean} encrypt - Toggle encryption for the attribute. Encryption enhances security by not storing any plain text values in the database. However, encrypted attributes cannot be queried.
      * @throws {AppwriteException}
      * @returns {Promise<Models.AttributeVarchar>}
      * @deprecated Use the object parameter style method for a better developer experience.
      */
-    createVarcharAttribute(databaseId: string, collectionId: string, key: string, size: number, required: boolean, xdefault?: string, array?: boolean): Promise<Models.AttributeVarchar>;
+    createVarcharAttribute(databaseId: string, collectionId: string, key: string, size: number, required: boolean, xdefault?: string, array?: boolean, encrypt?: boolean): Promise<Models.AttributeVarchar>;
     createVarcharAttribute(
-        paramsOrFirst: { databaseId: string, collectionId: string, key: string, size: number, required: boolean, xdefault?: string, array?: boolean } | string,
-        ...rest: [(string)?, (string)?, (number)?, (boolean)?, (string)?, (boolean)?]    
+        paramsOrFirst: { databaseId: string, collectionId: string, key: string, size: number, required: boolean, xdefault?: string, array?: boolean, encrypt?: boolean } | string,
+        ...rest: [(string)?, (string)?, (number)?, (boolean)?, (string)?, (boolean)?, (boolean)?]    
     ): Promise<Models.AttributeVarchar> {
-        let params: { databaseId: string, collectionId: string, key: string, size: number, required: boolean, xdefault?: string, array?: boolean };
+        let params: { databaseId: string, collectionId: string, key: string, size: number, required: boolean, xdefault?: string, array?: boolean, encrypt?: boolean };
         
         if ((paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst))) {
-            params = (paramsOrFirst || {}) as { databaseId: string, collectionId: string, key: string, size: number, required: boolean, xdefault?: string, array?: boolean };
+            params = (paramsOrFirst || {}) as { databaseId: string, collectionId: string, key: string, size: number, required: boolean, xdefault?: string, array?: boolean, encrypt?: boolean };
         } else {
             params = {
                 databaseId: paramsOrFirst as string,
@@ -4297,7 +4320,8 @@ export class Databases {
                 size: rest[2] as number,
                 required: rest[3] as boolean,
                 xdefault: rest[4] as string,
-                array: rest[5] as boolean            
+                array: rest[5] as boolean,
+                encrypt: rest[6] as boolean            
             };
         }
         
@@ -4308,6 +4332,7 @@ export class Databases {
         const required = params.required;
         const xdefault = params.xdefault;
         const array = params.array;
+        const encrypt = params.encrypt;
 
         if (typeof databaseId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "databaseId"');
@@ -4342,6 +4367,9 @@ export class Databases {
         if (typeof array !== 'undefined') {
             payload['array'] = array;
         }
+        if (typeof encrypt !== 'undefined') {
+            payload['encrypt'] = encrypt;
+        }
         const uri = new URL(this.client.config.endpoint + apiPath);
 
         const apiHeaders: { [header: string]: string } = {

package/src/services/domains.ts

@@ -2,6 +2,7 @@ import { Service } from '../service';
 import { AppwriteException, Client, type Payload, UploadProgress } from '../client';
 import type { Models } from '../models';
 
+import { RegistrationType } from '../enums/registration-type';
 import { FilterType } from '../enums/filter-type';
 
 export class Domains {
@@ -136,6 +137,75 @@ export class Domains {
         );
     }
 
+    /**
+     *     Get the registration price for a domain name.
+     *
+     * @param {string} params.domain - Domain name to get price for.
+     * @param {number} params.periodYears - Number of years to calculate the domain price for. Must be at least 1.
+     * @param {RegistrationType} params.registrationType - Type of registration pricing to fetch. Allowed values: new, transfer, renewal, trade.
+     * @throws {AppwriteException}
+     * @returns {Promise<Models.DomainPrice>}
+     */
+    getPrice(params: { domain: string, periodYears?: number, registrationType?: RegistrationType }): Promise<Models.DomainPrice>;
+    /**
+     *     Get the registration price for a domain name.
+     *
+     * @param {string} domain - Domain name to get price for.
+     * @param {number} periodYears - Number of years to calculate the domain price for. Must be at least 1.
+     * @param {RegistrationType} registrationType - Type of registration pricing to fetch. Allowed values: new, transfer, renewal, trade.
+     * @throws {AppwriteException}
+     * @returns {Promise<Models.DomainPrice>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    getPrice(domain: string, periodYears?: number, registrationType?: RegistrationType): Promise<Models.DomainPrice>;
+    getPrice(
+        paramsOrFirst: { domain: string, periodYears?: number, registrationType?: RegistrationType } | string,
+        ...rest: [(number)?, (RegistrationType)?]    
+    ): Promise<Models.DomainPrice> {
+        let params: { domain: string, periodYears?: number, registrationType?: RegistrationType };
+        
+        if ((paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst))) {
+            params = (paramsOrFirst || {}) as { domain: string, periodYears?: number, registrationType?: RegistrationType };
+        } else {
+            params = {
+                domain: paramsOrFirst as string,
+                periodYears: rest[0] as number,
+                registrationType: rest[1] as RegistrationType            
+            };
+        }
+        
+        const domain = params.domain;
+        const periodYears = params.periodYears;
+        const registrationType = params.registrationType;
+
+        if (typeof domain === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "domain"');
+        }
+
+        const apiPath = '/domains/price';
+        const payload: Payload = {};
+        if (typeof domain !== 'undefined') {
+            payload['domain'] = domain;
+        }
+        if (typeof periodYears !== 'undefined') {
+            payload['periodYears'] = periodYears;
+        }
+        if (typeof registrationType !== 'undefined') {
+            payload['registrationType'] = registrationType;
+        }
+        const uri = new URL(this.client.config.endpoint + apiPath);
+
+        const apiHeaders: { [header: string]: string } = {
+        }
+
+        return this.client.call(
+            'get',
+            uri,
+            apiHeaders,
+            payload
+        );
+    }
+
     /**
      *     List domain suggestions.
      *

package/src/services/functions.ts

@@ -343,7 +343,7 @@ export class Functions {
     ): Promise<Models.TemplateFunctionList> {
         let params: { runtimes?: Runtimes[], useCases?: UseCases[], limit?: number, offset?: number, total?: boolean };
         
-        if (!paramsOrFirst || (paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst) && 'runtimes' in paramsOrFirst)) {
+        if (!paramsOrFirst || (paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst) && ('runtimes' in paramsOrFirst || 'useCases' in paramsOrFirst || 'limit' in paramsOrFirst || 'offset' in paramsOrFirst || 'total' in paramsOrFirst))) {
             params = (paramsOrFirst || {}) as { runtimes?: Runtimes[], useCases?: UseCases[], limit?: number, offset?: number, total?: boolean };
         } else {
             params = {
@@ -465,7 +465,7 @@ export class Functions {
     ): Promise<Models.UsageFunctions> {
         let params: { range?: UsageRange };
         
-        if (!paramsOrFirst || (paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst) && 'range' in paramsOrFirst)) {
+        if (!paramsOrFirst || (paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst) && ('range' in paramsOrFirst))) {
             params = (paramsOrFirst || {}) as { range?: UsageRange };
         } else {
             params = {

package/src/services/graphql.ts

@@ -32,7 +32,7 @@ export class Graphql {
     ): Promise<{}> {
         let params: { query: object };
         
-        if ((paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst) && 'query' in paramsOrFirst)) {
+        if ((paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst) && ('query' in paramsOrFirst))) {
             params = (paramsOrFirst || {}) as { query: object };
         } else {
             params = {
@@ -88,7 +88,7 @@ export class Graphql {
     ): Promise<{}> {
         let params: { query: object };
         
-        if ((paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst) && 'query' in paramsOrFirst)) {
+        if ((paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst) && ('query' in paramsOrFirst))) {
             params = (paramsOrFirst || {}) as { query: object };
         } else {
             params = {

package/src/services/health.ts

@@ -620,7 +620,7 @@ export class Health {
     ): Promise<Models.HealthQueue> {
         let params: { name: Name, threshold?: number };
         
-        if ((paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst) && 'name' in paramsOrFirst)) {
+        if ((paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst) && ('name' in paramsOrFirst || 'threshold' in paramsOrFirst))) {
             params = (paramsOrFirst || {}) as { name: Name, threshold?: number };
         } else {
             params = {