@appwrite.io/console 0.0.1 → 0.1.0-preview-0.0

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
          *
@@ -515,6 +565,56 @@ export class Databases extends Service {
             }, 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
          *
@@ -572,6 +672,59 @@ export class Databases extends Service {
             }, 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
          *
@@ -636,6 +789,68 @@ export class Databases extends Service {
             }, 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
          *
@@ -704,6 +919,77 @@ export class Databases extends Service {
             }, 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
          *
@@ -772,6 +1058,77 @@ export class Databases extends Service {
             }, payload);
         }
 
+        /**
+         * Update Integer 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 {number} min
+         * @param {number} max
+         * @param {number} xdefault
+         * @throws {AppwriteException}
+         * @returns {Promise}
+         */
+        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"');
+            }
+
+            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/integer/{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 IP Address Attribute
          *
@@ -829,6 +1186,59 @@ export class Databases extends Service {
             }, payload);
         }
 
+        /**
+         * Update IP Address Attribute
+         *
+         * 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 {string} xdefault
+         * @throws {AppwriteException}
+         * @returns {Promise}
+         */
+        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"');
+            }
+
+            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/ip/{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 String Attribute
          *
@@ -895,6 +1305,59 @@ export class Databases extends Service {
             }, payload);
         }
 
+        /**
+         * Update String Attribute
+         *
+         * Update a string 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 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"');
+            }
+
+            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/string/{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 URL Attribute
          *
@@ -952,6 +1415,59 @@ export class Databases extends Service {
             }, payload);
         }
 
+        /**
+         * Update URL Attribute
+         *
+         * Update an url 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 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"');
+            }
+
+            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/url/{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);
+        }
+
         /**
          * Get Attribute
          *

package/src/services/functions.ts

@@ -48,8 +48,8 @@ export class Functions extends Service {
          *
          * @param {string} functionId
          * @param {string} name
-         * @param {string[]} execute
          * @param {string} runtime
+         * @param {string[]} execute
          * @param {string[]} events
          * @param {string} schedule
          * @param {number} timeout
@@ -57,7 +57,7 @@ export class Functions extends Service {
          * @throws {AppwriteException}
          * @returns {Promise}
          */
-        async create(functionId: string, name: string, execute: string[], runtime: string, events?: string[], schedule?: string, timeout?: number, enabled?: boolean): Promise<Models.Function> {
+        async create(functionId: string, name: string, runtime: string, execute?: string[], events?: string[], schedule?: string, timeout?: number, enabled?: boolean): Promise<Models.Function> {
             if (typeof functionId === 'undefined') {
                 throw new AppwriteException('Missing required parameter: "functionId"');
             }
@@ -66,10 +66,6 @@ export class Functions extends Service {
                 throw new AppwriteException('Missing required parameter: "name"');
             }
 
-            if (typeof execute === 'undefined') {
-                throw new AppwriteException('Missing required parameter: "execute"');
-            }
-
             if (typeof runtime === 'undefined') {
                 throw new AppwriteException('Missing required parameter: "runtime"');
             }
@@ -193,7 +189,7 @@ export class Functions extends Service {
          * @throws {AppwriteException}
          * @returns {Promise}
          */
-        async update(functionId: string, name: string, execute: string[], events?: string[], schedule?: string, timeout?: number, enabled?: boolean): Promise<Models.Function> {
+        async update(functionId: string, name: string, execute?: string[], events?: string[], schedule?: string, timeout?: number, enabled?: boolean): Promise<Models.Function> {
             if (typeof functionId === 'undefined') {
                 throw new AppwriteException('Missing required parameter: "functionId"');
             }
@@ -202,10 +198,6 @@ export class Functions extends Service {
                 throw new AppwriteException('Missing required parameter: "name"');
             }
 
-            if (typeof execute === 'undefined') {
-                throw new AppwriteException('Missing required parameter: "execute"');
-            }
-
             let path = '/functions/{functionId}'.replace('{functionId}', functionId);
             let payload: Payload = {};
 

package/src/services/projects.ts

@@ -353,6 +353,68 @@ export class Projects extends Service {
             }, payload);
         }
 
+        /**
+         * Update authentication password disctionary status. Use this endpoint to enable or disable the dicitonary check for user password
+         *
+         *
+         * @param {string} projectId
+         * @param {boolean} enabled
+         * @throws {AppwriteException}
+         * @returns {Promise}
+         */
+        async updateAuthPasswordDictionary(projectId: string, enabled: boolean): Promise<Models.Project> {
+            if (typeof projectId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "projectId"');
+            }
+
+            if (typeof enabled === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "enabled"');
+            }
+
+            let path = '/projects/{projectId}/auth/password-dictionary'.replace('{projectId}', projectId);
+            let payload: Payload = {};
+
+            if (typeof enabled !== 'undefined') {
+                payload['enabled'] = enabled;
+            }
+
+            const uri = new URL(this.client.config.endpoint + path);
+            return await this.client.call('patch', uri, {
+                'content-type': 'application/json',
+            }, payload);
+        }
+
+        /**
+         * Update authentication password history. Use this endpoint to set the number of password history to save and 0 to disable password history.
+         *
+         *
+         * @param {string} projectId
+         * @param {number} limit
+         * @throws {AppwriteException}
+         * @returns {Promise}
+         */
+        async updateAuthPasswordHistory(projectId: string, limit: number): Promise<Models.Project> {
+            if (typeof projectId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "projectId"');
+            }
+
+            if (typeof limit === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "limit"');
+            }
+
+            let path = '/projects/{projectId}/auth/password-history'.replace('{projectId}', projectId);
+            let payload: Payload = {};
+
+            if (typeof limit !== 'undefined') {
+                payload['limit'] = limit;
+            }
+
+            const uri = new URL(this.client.config.endpoint + path);
+            return await this.client.call('patch', uri, {
+                'content-type': 'application/json',
+            }, payload);
+        }
+
         /**
          * Update Project auth method status. Use this endpoint to enable or disable a given auth method for this project.
          *