@appwrite.io/console 0.0.2-preview-0.0 → 0.1.0-preview-0.1

package/src/services/databases.ts

@@ -460,6 +460,56 @@ export class Databases extends Service {
             }, payload);
         }
 
+        /**
+         * Update Boolean Attribute
+         *
+         *
+         * @param {string} databaseId
+         * @param {string} collectionId
+         * @param {string} key
+         * @param {boolean} required
+         * @param {boolean} xdefault
+         * @throws {AppwriteException}
+         * @returns {Promise}
+         */
+        async updateBooleanAttribute(databaseId: string, collectionId: string, key: string, required: boolean, xdefault: boolean): Promise<Models.AttributeBoolean> {
+            if (typeof databaseId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "databaseId"');
+            }
+
+            if (typeof collectionId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "collectionId"');
+            }
+
+            if (typeof key === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "key"');
+            }
+
+            if (typeof required === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "required"');
+            }
+
+            if (typeof xdefault === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "xdefault"');
+            }
+
+            let path = '/databases/{databaseId}/collections/{collectionId}/attributes/boolean/{key}'.replace('{databaseId}', databaseId).replace('{collectionId}', collectionId).replace('{key}', key);
+            let payload: Payload = {};
+
+            if (typeof required !== 'undefined') {
+                payload['required'] = required;
+            }
+
+            if (typeof xdefault !== 'undefined') {
+                payload['default'] = xdefault;
+            }
+
+            const uri = new URL(this.client.config.endpoint + path);
+            return await this.client.call('patch', uri, {
+                'content-type': 'application/json',
+            }, payload);
+        }
+
         /**
          * Create DateTime Attribute
          *
@@ -468,12 +518,497 @@ export class Databases extends Service {
          * @param {string} collectionId
          * @param {string} key
          * @param {boolean} required
-         * @param {string} xdefault
+         * @param {string} xdefault
+         * @param {boolean} array
+         * @throws {AppwriteException}
+         * @returns {Promise}
+         */
+        async createDatetimeAttribute(databaseId: string, collectionId: string, key: string, required: boolean, xdefault?: string, array?: boolean): Promise<Models.AttributeDatetime> {
+            if (typeof databaseId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "databaseId"');
+            }
+
+            if (typeof collectionId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "collectionId"');
+            }
+
+            if (typeof key === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "key"');
+            }
+
+            if (typeof required === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "required"');
+            }
+
+            let path = '/databases/{databaseId}/collections/{collectionId}/attributes/datetime'.replace('{databaseId}', databaseId).replace('{collectionId}', collectionId);
+            let payload: Payload = {};
+
+            if (typeof key !== 'undefined') {
+                payload['key'] = key;
+            }
+
+            if (typeof required !== 'undefined') {
+                payload['required'] = required;
+            }
+
+            if (typeof xdefault !== 'undefined') {
+                payload['default'] = xdefault;
+            }
+
+            if (typeof array !== 'undefined') {
+                payload['array'] = array;
+            }
+
+            const uri = new URL(this.client.config.endpoint + path);
+            return await this.client.call('post', uri, {
+                'content-type': 'application/json',
+            }, payload);
+        }
+
+        /**
+         * Update DateTime Attribute
+         *
+         *
+         * @param {string} databaseId
+         * @param {string} collectionId
+         * @param {string} key
+         * @param {boolean} required
+         * @param {string} xdefault
+         * @throws {AppwriteException}
+         * @returns {Promise}
+         */
+        async updateDatetimeAttribute(databaseId: string, collectionId: string, key: string, required: boolean, xdefault: string): Promise<Models.AttributeDatetime> {
+            if (typeof databaseId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "databaseId"');
+            }
+
+            if (typeof collectionId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "collectionId"');
+            }
+
+            if (typeof key === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "key"');
+            }
+
+            if (typeof required === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "required"');
+            }
+
+            if (typeof xdefault === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "xdefault"');
+            }
+
+            let path = '/databases/{databaseId}/collections/{collectionId}/attributes/datetime/{key}'.replace('{databaseId}', databaseId).replace('{collectionId}', collectionId).replace('{key}', key);
+            let payload: Payload = {};
+
+            if (typeof required !== 'undefined') {
+                payload['required'] = required;
+            }
+
+            if (typeof xdefault !== 'undefined') {
+                payload['default'] = xdefault;
+            }
+
+            const uri = new URL(this.client.config.endpoint + path);
+            return await this.client.call('patch', uri, {
+                'content-type': 'application/json',
+            }, payload);
+        }
+
+        /**
+         * Create Email Attribute
+         *
+         * Create an email attribute.
+         * 
+         *
+         * @param {string} databaseId
+         * @param {string} collectionId
+         * @param {string} key
+         * @param {boolean} required
+         * @param {string} xdefault
+         * @param {boolean} array
+         * @throws {AppwriteException}
+         * @returns {Promise}
+         */
+        async createEmailAttribute(databaseId: string, collectionId: string, key: string, required: boolean, xdefault?: string, array?: boolean): Promise<Models.AttributeEmail> {
+            if (typeof databaseId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "databaseId"');
+            }
+
+            if (typeof collectionId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "collectionId"');
+            }
+
+            if (typeof key === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "key"');
+            }
+
+            if (typeof required === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "required"');
+            }
+
+            let path = '/databases/{databaseId}/collections/{collectionId}/attributes/email'.replace('{databaseId}', databaseId).replace('{collectionId}', collectionId);
+            let payload: Payload = {};
+
+            if (typeof key !== 'undefined') {
+                payload['key'] = key;
+            }
+
+            if (typeof required !== 'undefined') {
+                payload['required'] = required;
+            }
+
+            if (typeof xdefault !== 'undefined') {
+                payload['default'] = xdefault;
+            }
+
+            if (typeof array !== 'undefined') {
+                payload['array'] = array;
+            }
+
+            const uri = new URL(this.client.config.endpoint + path);
+            return await this.client.call('post', uri, {
+                'content-type': 'application/json',
+            }, payload);
+        }
+
+        /**
+         * Update Email Attribute
+         *
+         * Update an email attribute. Changing the `default` value will not update
+         * already existing documents.
+         * 
+         *
+         * @param {string} databaseId
+         * @param {string} collectionId
+         * @param {string} key
+         * @param {boolean} required
+         * @param {string} xdefault
+         * @throws {AppwriteException}
+         * @returns {Promise}
+         */
+        async updateEmailAttribute(databaseId: string, collectionId: string, key: string, required: boolean, xdefault: string): Promise<Models.AttributeEmail> {
+            if (typeof databaseId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "databaseId"');
+            }
+
+            if (typeof collectionId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "collectionId"');
+            }
+
+            if (typeof key === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "key"');
+            }
+
+            if (typeof required === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "required"');
+            }
+
+            if (typeof xdefault === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "xdefault"');
+            }
+
+            let path = '/databases/{databaseId}/collections/{collectionId}/attributes/email/{key}'.replace('{databaseId}', databaseId).replace('{collectionId}', collectionId).replace('{key}', key);
+            let payload: Payload = {};
+
+            if (typeof required !== 'undefined') {
+                payload['required'] = required;
+            }
+
+            if (typeof xdefault !== 'undefined') {
+                payload['default'] = xdefault;
+            }
+
+            const uri = new URL(this.client.config.endpoint + path);
+            return await this.client.call('patch', uri, {
+                'content-type': 'application/json',
+            }, payload);
+        }
+
+        /**
+         * Create Enum Attribute
+         *
+         *
+         * @param {string} databaseId
+         * @param {string} collectionId
+         * @param {string} key
+         * @param {string[]} elements
+         * @param {boolean} required
+         * @param {string} xdefault
+         * @param {boolean} array
+         * @throws {AppwriteException}
+         * @returns {Promise}
+         */
+        async createEnumAttribute(databaseId: string, collectionId: string, key: string, elements: string[], required: boolean, xdefault?: string, array?: boolean): Promise<Models.AttributeEnum> {
+            if (typeof databaseId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "databaseId"');
+            }
+
+            if (typeof collectionId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "collectionId"');
+            }
+
+            if (typeof key === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "key"');
+            }
+
+            if (typeof elements === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "elements"');
+            }
+
+            if (typeof required === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "required"');
+            }
+
+            let path = '/databases/{databaseId}/collections/{collectionId}/attributes/enum'.replace('{databaseId}', databaseId).replace('{collectionId}', collectionId);
+            let payload: Payload = {};
+
+            if (typeof key !== 'undefined') {
+                payload['key'] = key;
+            }
+
+            if (typeof elements !== 'undefined') {
+                payload['elements'] = elements;
+            }
+
+            if (typeof required !== 'undefined') {
+                payload['required'] = required;
+            }
+
+            if (typeof xdefault !== 'undefined') {
+                payload['default'] = xdefault;
+            }
+
+            if (typeof array !== 'undefined') {
+                payload['array'] = array;
+            }
+
+            const uri = new URL(this.client.config.endpoint + path);
+            return await this.client.call('post', uri, {
+                'content-type': 'application/json',
+            }, payload);
+        }
+
+        /**
+         * Update Enum Attribute
+         *
+         * Update an enum attribute. Changing the `default` value will not update
+         * already existing documents.
+         * 
+         *
+         * @param {string} databaseId
+         * @param {string} collectionId
+         * @param {string} key
+         * @param {string[]} elements
+         * @param {boolean} required
+         * @param {string} xdefault
+         * @throws {AppwriteException}
+         * @returns {Promise}
+         */
+        async updateEnumAttribute(databaseId: string, collectionId: string, key: string, elements: string[], required: boolean, xdefault: string): Promise<Models.AttributeEnum> {
+            if (typeof databaseId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "databaseId"');
+            }
+
+            if (typeof collectionId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "collectionId"');
+            }
+
+            if (typeof key === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "key"');
+            }
+
+            if (typeof elements === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "elements"');
+            }
+
+            if (typeof required === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "required"');
+            }
+
+            if (typeof xdefault === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "xdefault"');
+            }
+
+            let path = '/databases/{databaseId}/collections/{collectionId}/attributes/enum/{key}'.replace('{databaseId}', databaseId).replace('{collectionId}', collectionId).replace('{key}', key);
+            let payload: Payload = {};
+
+            if (typeof elements !== 'undefined') {
+                payload['elements'] = elements;
+            }
+
+            if (typeof required !== 'undefined') {
+                payload['required'] = required;
+            }
+
+            if (typeof xdefault !== 'undefined') {
+                payload['default'] = xdefault;
+            }
+
+            const uri = new URL(this.client.config.endpoint + path);
+            return await this.client.call('patch', uri, {
+                'content-type': 'application/json',
+            }, payload);
+        }
+
+        /**
+         * Create Float Attribute
+         *
+         * Create a float attribute. Optionally, minimum and maximum values can be
+         * provided.
+         * 
+         *
+         * @param {string} databaseId
+         * @param {string} collectionId
+         * @param {string} key
+         * @param {boolean} required
+         * @param {number} min
+         * @param {number} max
+         * @param {number} xdefault
+         * @param {boolean} array
+         * @throws {AppwriteException}
+         * @returns {Promise}
+         */
+        async createFloatAttribute(databaseId: string, collectionId: string, key: string, required: boolean, min?: number, max?: number, xdefault?: number, array?: boolean): Promise<Models.AttributeFloat> {
+            if (typeof databaseId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "databaseId"');
+            }
+
+            if (typeof collectionId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "collectionId"');
+            }
+
+            if (typeof key === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "key"');
+            }
+
+            if (typeof required === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "required"');
+            }
+
+            let path = '/databases/{databaseId}/collections/{collectionId}/attributes/float'.replace('{databaseId}', databaseId).replace('{collectionId}', collectionId);
+            let payload: Payload = {};
+
+            if (typeof key !== 'undefined') {
+                payload['key'] = key;
+            }
+
+            if (typeof required !== 'undefined') {
+                payload['required'] = required;
+            }
+
+            if (typeof min !== 'undefined') {
+                payload['min'] = min;
+            }
+
+            if (typeof max !== 'undefined') {
+                payload['max'] = max;
+            }
+
+            if (typeof xdefault !== 'undefined') {
+                payload['default'] = xdefault;
+            }
+
+            if (typeof array !== 'undefined') {
+                payload['array'] = array;
+            }
+
+            const uri = new URL(this.client.config.endpoint + path);
+            return await this.client.call('post', uri, {
+                'content-type': 'application/json',
+            }, payload);
+        }
+
+        /**
+         * Update Float Attribute
+         *
+         * Update a float attribute. Changing the `default` value will not update
+         * already existing documents.
+         * 
+         *
+         * @param {string} databaseId
+         * @param {string} collectionId
+         * @param {string} key
+         * @param {boolean} required
+         * @param {number} min
+         * @param {number} max
+         * @param {number} xdefault
+         * @throws {AppwriteException}
+         * @returns {Promise}
+         */
+        async updateFloatAttribute(databaseId: string, collectionId: string, key: string, required: boolean, min: number, max: number, xdefault: number): Promise<Models.AttributeFloat> {
+            if (typeof databaseId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "databaseId"');
+            }
+
+            if (typeof collectionId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "collectionId"');
+            }
+
+            if (typeof key === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "key"');
+            }
+
+            if (typeof required === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "required"');
+            }
+
+            if (typeof min === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "min"');
+            }
+
+            if (typeof max === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "max"');
+            }
+
+            if (typeof xdefault === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "xdefault"');
+            }
+
+            let path = '/databases/{databaseId}/collections/{collectionId}/attributes/float/{key}'.replace('{databaseId}', databaseId).replace('{collectionId}', collectionId).replace('{key}', key);
+            let payload: Payload = {};
+
+            if (typeof required !== 'undefined') {
+                payload['required'] = required;
+            }
+
+            if (typeof min !== 'undefined') {
+                payload['min'] = min;
+            }
+
+            if (typeof max !== 'undefined') {
+                payload['max'] = max;
+            }
+
+            if (typeof xdefault !== 'undefined') {
+                payload['default'] = xdefault;
+            }
+
+            const uri = new URL(this.client.config.endpoint + path);
+            return await this.client.call('patch', uri, {
+                'content-type': 'application/json',
+            }, payload);
+        }
+
+        /**
+         * Create Integer Attribute
+         *
+         * Create an integer attribute. Optionally, minimum and maximum values can be
+         * provided.
+         * 
+         *
+         * @param {string} databaseId
+         * @param {string} collectionId
+         * @param {string} key
+         * @param {boolean} required
+         * @param {number} min
+         * @param {number} max
+         * @param {number} xdefault
          * @param {boolean} array
          * @throws {AppwriteException}
          * @returns {Promise}
          */
-        async createDatetimeAttribute(databaseId: string, collectionId: string, key: string, required: boolean, xdefault?: string, array?: boolean): Promise<Models.AttributeDatetime> {
+        async createIntegerAttribute(databaseId: string, collectionId: string, key: string, required: boolean, min?: number, max?: number, xdefault?: number, array?: boolean): Promise<Models.AttributeInteger> {
             if (typeof databaseId === 'undefined') {
                 throw new AppwriteException('Missing required parameter: "databaseId"');
             }
@@ -490,7 +1025,7 @@ export class Databases extends Service {
                 throw new AppwriteException('Missing required parameter: "required"');
             }
 
-            let path = '/databases/{databaseId}/collections/{collectionId}/attributes/datetime'.replace('{databaseId}', databaseId).replace('{collectionId}', collectionId);
+            let path = '/databases/{databaseId}/collections/{collectionId}/attributes/integer'.replace('{databaseId}', databaseId).replace('{collectionId}', collectionId);
             let payload: Payload = {};
 
             if (typeof key !== 'undefined') {
@@ -501,6 +1036,14 @@ export class Databases extends Service {
                 payload['required'] = required;
             }
 
+            if (typeof min !== 'undefined') {
+                payload['min'] = min;
+            }
+
+            if (typeof max !== 'undefined') {
+                payload['max'] = max;
+            }
+
             if (typeof xdefault !== 'undefined') {
                 payload['default'] = xdefault;
             }
@@ -516,21 +1059,23 @@ export class Databases extends Service {
         }
 
         /**
-         * Create Email Attribute
+         * Update Integer Attribute
          *
-         * Create an email attribute.
+         * Update an integer attribute. Changing the `default` value will not update
+         * already existing documents.
          * 
          *
          * @param {string} databaseId
          * @param {string} collectionId
          * @param {string} key
          * @param {boolean} required
-         * @param {string} xdefault
-         * @param {boolean} array
+         * @param {number} min
+         * @param {number} max
+         * @param {number} xdefault
          * @throws {AppwriteException}
          * @returns {Promise}
          */
-        async createEmailAttribute(databaseId: string, collectionId: string, key: string, required: boolean, xdefault?: string, array?: boolean): Promise<Models.AttributeEmail> {
+        async updateIntegerAttribute(databaseId: string, collectionId: string, key: string, required: boolean, min: number, max: number, xdefault: number): Promise<Models.AttributeInteger> {
             if (typeof databaseId === 'undefined') {
                 throw new AppwriteException('Missing required parameter: "databaseId"');
             }
@@ -547,46 +1092,59 @@ export class Databases extends Service {
                 throw new AppwriteException('Missing required parameter: "required"');
             }
 
-            let path = '/databases/{databaseId}/collections/{collectionId}/attributes/email'.replace('{databaseId}', databaseId).replace('{collectionId}', collectionId);
-            let payload: Payload = {};
+            if (typeof min === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "min"');
+            }
 
-            if (typeof key !== 'undefined') {
-                payload['key'] = key;
+            if (typeof max === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "max"');
+            }
+
+            if (typeof xdefault === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "xdefault"');
             }
 
+            let path = '/databases/{databaseId}/collections/{collectionId}/attributes/integer/{key}'.replace('{databaseId}', databaseId).replace('{collectionId}', collectionId).replace('{key}', key);
+            let payload: Payload = {};
+
             if (typeof required !== 'undefined') {
                 payload['required'] = required;
             }
 
-            if (typeof xdefault !== 'undefined') {
-                payload['default'] = xdefault;
+            if (typeof min !== 'undefined') {
+                payload['min'] = min;
             }
 
-            if (typeof array !== 'undefined') {
-                payload['array'] = array;
+            if (typeof max !== 'undefined') {
+                payload['max'] = max;
+            }
+
+            if (typeof xdefault !== 'undefined') {
+                payload['default'] = xdefault;
             }
 
             const uri = new URL(this.client.config.endpoint + path);
-            return await this.client.call('post', uri, {
+            return await this.client.call('patch', uri, {
                 'content-type': 'application/json',
             }, payload);
         }
 
         /**
-         * Create Enum Attribute
+         * Create IP Address Attribute
          *
+         * Create IP address attribute.
+         * 
          *
          * @param {string} databaseId
          * @param {string} collectionId
          * @param {string} key
-         * @param {string[]} elements
          * @param {boolean} required
          * @param {string} xdefault
          * @param {boolean} array
          * @throws {AppwriteException}
          * @returns {Promise}
          */
-        async createEnumAttribute(databaseId: string, collectionId: string, key: string, elements: string[], required: boolean, xdefault?: string, array?: boolean): Promise<Models.AttributeEnum> {
+        async createIpAttribute(databaseId: string, collectionId: string, key: string, required: boolean, xdefault?: string, array?: boolean): Promise<Models.AttributeIp> {
             if (typeof databaseId === 'undefined') {
                 throw new AppwriteException('Missing required parameter: "databaseId"');
             }
@@ -599,25 +1157,17 @@ export class Databases extends Service {
                 throw new AppwriteException('Missing required parameter: "key"');
             }
 
-            if (typeof elements === 'undefined') {
-                throw new AppwriteException('Missing required parameter: "elements"');
-            }
-
             if (typeof required === 'undefined') {
                 throw new AppwriteException('Missing required parameter: "required"');
             }
 
-            let path = '/databases/{databaseId}/collections/{collectionId}/attributes/enum'.replace('{databaseId}', databaseId).replace('{collectionId}', collectionId);
+            let path = '/databases/{databaseId}/collections/{collectionId}/attributes/ip'.replace('{databaseId}', databaseId).replace('{collectionId}', collectionId);
             let payload: Payload = {};
 
             if (typeof key !== 'undefined') {
                 payload['key'] = key;
             }
 
-            if (typeof elements !== 'undefined') {
-                payload['elements'] = elements;
-            }
-
             if (typeof required !== 'undefined') {
                 payload['required'] = required;
             }
@@ -637,24 +1187,21 @@ export class Databases extends Service {
         }
 
         /**
-         * Create Float Attribute
+         * Update IP Address Attribute
          *
-         * Create a float attribute. Optionally, minimum and maximum values can be
-         * provided.
+         * Update an ip attribute. Changing the `default` value will not update
+         * already existing documents.
          * 
          *
          * @param {string} databaseId
          * @param {string} collectionId
          * @param {string} key
          * @param {boolean} required
-         * @param {number} min
-         * @param {number} max
-         * @param {number} xdefault
-         * @param {boolean} array
+         * @param {string} xdefault
          * @throws {AppwriteException}
          * @returns {Promise}
          */
-        async createFloatAttribute(databaseId: string, collectionId: string, key: string, required: boolean, min?: number, max?: number, xdefault?: number, array?: boolean): Promise<Models.AttributeFloat> {
+        async updateIpAttribute(databaseId: string, collectionId: string, key: string, required: boolean, xdefault: string): Promise<Models.AttributeIp> {
             if (typeof databaseId === 'undefined') {
                 throw new AppwriteException('Missing required parameter: "databaseId"');
             }
@@ -671,31 +1218,84 @@ export class Databases extends Service {
                 throw new AppwriteException('Missing required parameter: "required"');
             }
 
-            let path = '/databases/{databaseId}/collections/{collectionId}/attributes/float'.replace('{databaseId}', databaseId).replace('{collectionId}', collectionId);
-            let payload: Payload = {};
-
-            if (typeof key !== 'undefined') {
-                payload['key'] = key;
+            if (typeof xdefault === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "xdefault"');
             }
 
+            let path = '/databases/{databaseId}/collections/{collectionId}/attributes/ip/{key}'.replace('{databaseId}', databaseId).replace('{collectionId}', collectionId).replace('{key}', key);
+            let payload: Payload = {};
+
             if (typeof required !== 'undefined') {
                 payload['required'] = required;
             }
 
-            if (typeof min !== 'undefined') {
-                payload['min'] = min;
+            if (typeof xdefault !== 'undefined') {
+                payload['default'] = xdefault;
             }
 
-            if (typeof max !== 'undefined') {
-                payload['max'] = max;
+            const uri = new URL(this.client.config.endpoint + path);
+            return await this.client.call('patch', uri, {
+                'content-type': 'application/json',
+            }, payload);
+        }
+
+        /**
+         * Create relationship Attribute
+         *
+         *
+         * @param {string} databaseId
+         * @param {string} collectionId
+         * @param {string} relatedCollectionId
+         * @param {string} type
+         * @param {boolean} twoWay
+         * @param {string} key
+         * @param {string} twoWayKey
+         * @param {string} onDelete
+         * @throws {AppwriteException}
+         * @returns {Promise}
+         */
+        async createRelationshipAttribute(databaseId: string, collectionId: string, relatedCollectionId: string, type: string, twoWay?: boolean, key?: string, twoWayKey?: string, onDelete?: string): Promise<Models.AttributeRelationship> {
+            if (typeof databaseId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "databaseId"');
             }
 
-            if (typeof xdefault !== 'undefined') {
-                payload['default'] = xdefault;
+            if (typeof collectionId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "collectionId"');
             }
 
-            if (typeof array !== 'undefined') {
-                payload['array'] = array;
+            if (typeof relatedCollectionId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "relatedCollectionId"');
+            }
+
+            if (typeof type === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "type"');
+            }
+
+            let path = '/databases/{databaseId}/collections/{collectionId}/attributes/relationship'.replace('{databaseId}', databaseId).replace('{collectionId}', collectionId);
+            let payload: Payload = {};
+
+            if (typeof relatedCollectionId !== 'undefined') {
+                payload['relatedCollectionId'] = relatedCollectionId;
+            }
+
+            if (typeof type !== 'undefined') {
+                payload['type'] = type;
+            }
+
+            if (typeof twoWay !== 'undefined') {
+                payload['twoWay'] = twoWay;
+            }
+
+            if (typeof key !== 'undefined') {
+                payload['key'] = key;
+            }
+
+            if (typeof twoWayKey !== 'undefined') {
+                payload['twoWayKey'] = twoWayKey;
+            }
+
+            if (typeof onDelete !== 'undefined') {
+                payload['onDelete'] = onDelete;
             }
 
             const uri = new URL(this.client.config.endpoint + path);
@@ -705,24 +1305,22 @@ export class Databases extends Service {
         }
 
         /**
-         * Create Integer Attribute
+         * Create String Attribute
          *
-         * Create an integer attribute. Optionally, minimum and maximum values can be
-         * provided.
+         * Create a string attribute.
          * 
          *
          * @param {string} databaseId
          * @param {string} collectionId
          * @param {string} key
+         * @param {number} size
          * @param {boolean} required
-         * @param {number} min
-         * @param {number} max
-         * @param {number} xdefault
+         * @param {string} xdefault
          * @param {boolean} array
          * @throws {AppwriteException}
          * @returns {Promise}
          */
-        async createIntegerAttribute(databaseId: string, collectionId: string, key: string, required: boolean, min?: number, max?: number, xdefault?: number, array?: boolean): Promise<Models.AttributeInteger> {
+        async createStringAttribute(databaseId: string, collectionId: string, key: string, size: number, required: boolean, xdefault?: string, array?: boolean): Promise<Models.AttributeString> {
             if (typeof databaseId === 'undefined') {
                 throw new AppwriteException('Missing required parameter: "databaseId"');
             }
@@ -735,27 +1333,27 @@ export class Databases extends Service {
                 throw new AppwriteException('Missing required parameter: "key"');
             }
 
+            if (typeof size === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "size"');
+            }
+
             if (typeof required === 'undefined') {
                 throw new AppwriteException('Missing required parameter: "required"');
             }
 
-            let path = '/databases/{databaseId}/collections/{collectionId}/attributes/integer'.replace('{databaseId}', databaseId).replace('{collectionId}', collectionId);
+            let path = '/databases/{databaseId}/collections/{collectionId}/attributes/string'.replace('{databaseId}', databaseId).replace('{collectionId}', collectionId);
             let payload: Payload = {};
 
             if (typeof key !== 'undefined') {
                 payload['key'] = key;
             }
 
-            if (typeof required !== 'undefined') {
-                payload['required'] = required;
-            }
-
-            if (typeof min !== 'undefined') {
-                payload['min'] = min;
+            if (typeof size !== 'undefined') {
+                payload['size'] = size;
             }
 
-            if (typeof max !== 'undefined') {
-                payload['max'] = max;
+            if (typeof required !== 'undefined') {
+                payload['required'] = required;
             }
 
             if (typeof xdefault !== 'undefined') {
@@ -773,9 +1371,10 @@ export class Databases extends Service {
         }
 
         /**
-         * Create IP Address Attribute
+         * Update String Attribute
          *
-         * Create IP address attribute.
+         * Update a string attribute. Changing the `default` value will not update
+         * already existing documents.
          * 
          *
          * @param {string} databaseId
@@ -783,11 +1382,10 @@ export class Databases extends Service {
          * @param {string} key
          * @param {boolean} required
          * @param {string} xdefault
-         * @param {boolean} array
          * @throws {AppwriteException}
          * @returns {Promise}
          */
-        async createIpAttribute(databaseId: string, collectionId: string, key: string, required: boolean, xdefault?: string, array?: boolean): Promise<Models.AttributeIp> {
+        async updateStringAttribute(databaseId: string, collectionId: string, key: string, required: boolean, xdefault: string): Promise<Models.AttributeString> {
             if (typeof databaseId === 'undefined') {
                 throw new AppwriteException('Missing required parameter: "databaseId"');
             }
@@ -804,13 +1402,13 @@ export class Databases extends Service {
                 throw new AppwriteException('Missing required parameter: "required"');
             }
 
-            let path = '/databases/{databaseId}/collections/{collectionId}/attributes/ip'.replace('{databaseId}', databaseId).replace('{collectionId}', collectionId);
-            let payload: Payload = {};
-
-            if (typeof key !== 'undefined') {
-                payload['key'] = key;
+            if (typeof xdefault === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "xdefault"');
             }
 
+            let path = '/databases/{databaseId}/collections/{collectionId}/attributes/string/{key}'.replace('{databaseId}', databaseId).replace('{collectionId}', collectionId).replace('{key}', key);
+            let payload: Payload = {};
+
             if (typeof required !== 'undefined') {
                 payload['required'] = required;
             }
@@ -819,33 +1417,28 @@ export class Databases extends Service {
                 payload['default'] = xdefault;
             }
 
-            if (typeof array !== 'undefined') {
-                payload['array'] = array;
-            }
-
             const uri = new URL(this.client.config.endpoint + path);
-            return await this.client.call('post', uri, {
+            return await this.client.call('patch', uri, {
                 'content-type': 'application/json',
             }, payload);
         }
 
         /**
-         * Create String Attribute
+         * Create URL Attribute
          *
-         * Create a string attribute.
+         * Create a URL attribute.
          * 
          *
          * @param {string} databaseId
          * @param {string} collectionId
          * @param {string} key
-         * @param {number} size
          * @param {boolean} required
          * @param {string} xdefault
          * @param {boolean} array
          * @throws {AppwriteException}
          * @returns {Promise}
          */
-        async createStringAttribute(databaseId: string, collectionId: string, key: string, size: number, required: boolean, xdefault?: string, array?: boolean): Promise<Models.AttributeString> {
+        async createUrlAttribute(databaseId: string, collectionId: string, key: string, required: boolean, xdefault?: string, array?: boolean): Promise<Models.AttributeUrl> {
             if (typeof databaseId === 'undefined') {
                 throw new AppwriteException('Missing required parameter: "databaseId"');
             }
@@ -858,25 +1451,17 @@ export class Databases extends Service {
                 throw new AppwriteException('Missing required parameter: "key"');
             }
 
-            if (typeof size === 'undefined') {
-                throw new AppwriteException('Missing required parameter: "size"');
-            }
-
             if (typeof required === 'undefined') {
                 throw new AppwriteException('Missing required parameter: "required"');
             }
 
-            let path = '/databases/{databaseId}/collections/{collectionId}/attributes/string'.replace('{databaseId}', databaseId).replace('{collectionId}', collectionId);
+            let path = '/databases/{databaseId}/collections/{collectionId}/attributes/url'.replace('{databaseId}', databaseId).replace('{collectionId}', collectionId);
             let payload: Payload = {};
 
             if (typeof key !== 'undefined') {
                 payload['key'] = key;
             }
 
-            if (typeof size !== 'undefined') {
-                payload['size'] = size;
-            }
-
             if (typeof required !== 'undefined') {
                 payload['required'] = required;
             }
@@ -896,9 +1481,10 @@ export class Databases extends Service {
         }
 
         /**
-         * Create URL Attribute
+         * Update URL Attribute
          *
-         * Create a URL attribute.
+         * Update an url attribute. Changing the `default` value will not update
+         * already existing documents.
          * 
          *
          * @param {string} databaseId
@@ -906,11 +1492,10 @@ export class Databases extends Service {
          * @param {string} key
          * @param {boolean} required
          * @param {string} xdefault
-         * @param {boolean} array
          * @throws {AppwriteException}
          * @returns {Promise}
          */
-        async createUrlAttribute(databaseId: string, collectionId: string, key: string, required: boolean, xdefault?: string, array?: boolean): Promise<Models.AttributeUrl> {
+        async updateUrlAttribute(databaseId: string, collectionId: string, key: string, required: boolean, xdefault: string): Promise<Models.AttributeUrl> {
             if (typeof databaseId === 'undefined') {
                 throw new AppwriteException('Missing required parameter: "databaseId"');
             }
@@ -927,13 +1512,13 @@ export class Databases extends Service {
                 throw new AppwriteException('Missing required parameter: "required"');
             }
 
-            let path = '/databases/{databaseId}/collections/{collectionId}/attributes/url'.replace('{databaseId}', databaseId).replace('{collectionId}', collectionId);
-            let payload: Payload = {};
-
-            if (typeof key !== 'undefined') {
-                payload['key'] = key;
+            if (typeof xdefault === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "xdefault"');
             }
 
+            let path = '/databases/{databaseId}/collections/{collectionId}/attributes/url/{key}'.replace('{databaseId}', databaseId).replace('{collectionId}', collectionId).replace('{key}', key);
+            let payload: Payload = {};
+
             if (typeof required !== 'undefined') {
                 payload['required'] = required;
             }
@@ -942,12 +1527,8 @@ export class Databases extends Service {
                 payload['default'] = xdefault;
             }
 
-            if (typeof array !== 'undefined') {
-                payload['array'] = array;
-            }
-
             const uri = new URL(this.client.config.endpoint + path);
-            return await this.client.call('post', uri, {
+            return await this.client.call('patch', uri, {
                 'content-type': 'application/json',
             }, payload);
         }
@@ -1016,6 +1597,48 @@ export class Databases extends Service {
             }, payload);
         }
 
+        /**
+         * Update Relationship Attribute
+         *
+         *
+         * @param {string} databaseId
+         * @param {string} collectionId
+         * @param {string} key
+         * @param {boolean} twoWay
+         * @param {string} onDelete
+         * @throws {AppwriteException}
+         * @returns {Promise}
+         */
+        async updateRelationshipAttribute(databaseId: string, collectionId: string, key: string, twoWay?: boolean, onDelete?: string): Promise<Models.AttributeRelationship> {
+            if (typeof databaseId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "databaseId"');
+            }
+
+            if (typeof collectionId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "collectionId"');
+            }
+
+            if (typeof key === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "key"');
+            }
+
+            let path = '/databases/{databaseId}/collections/{collectionId}/attributes/{key}/relationship'.replace('{databaseId}', databaseId).replace('{collectionId}', collectionId).replace('{key}', key);
+            let payload: Payload = {};
+
+            if (typeof twoWay !== 'undefined') {
+                payload['twoWay'] = twoWay;
+            }
+
+            if (typeof onDelete !== 'undefined') {
+                payload['onDelete'] = onDelete;
+            }
+
+            const uri = new URL(this.client.config.endpoint + path);
+            return await this.client.call('patch', uri, {
+                'content-type': 'application/json',
+            }, payload);
+        }
+
         /**
          * List Documents
          *
@@ -1113,10 +1736,11 @@ export class Databases extends Service {
          * @param {string} databaseId
          * @param {string} collectionId
          * @param {string} documentId
+         * @param {string[]} queries
          * @throws {AppwriteException}
          * @returns {Promise}
          */
-        async getDocument<Document extends Models.Document>(databaseId: string, collectionId: string, documentId: string): Promise<Document> {
+        async getDocument<Document extends Models.Document>(databaseId: string, collectionId: string, documentId: string, queries?: string[]): Promise<Document> {
             if (typeof databaseId === 'undefined') {
                 throw new AppwriteException('Missing required parameter: "databaseId"');
             }
@@ -1132,6 +1756,10 @@ export class Databases extends Service {
             let path = '/databases/{databaseId}/collections/{collectionId}/documents/{documentId}'.replace('{databaseId}', databaseId).replace('{collectionId}', collectionId).replace('{documentId}', documentId);
             let payload: Payload = {};
 
+            if (typeof queries !== 'undefined') {
+                payload['queries'] = queries;
+            }
+
             const uri = new URL(this.client.config.endpoint + path);
             return await this.client.call('get', uri, {
                 'content-type': 'application/json',