@appwrite.io/console 0.1.1 → 0.3.0

package/src/services/functions.ts

@@ -10,797 +10,953 @@ export class Functions extends Service {
         super(client);
      }
 
-        /**
-         * List Functions
-         *
-         * Get a list of all the project's functions. You can use the query params to
-         * filter your results.
-         *
-         * @param {string[]} queries
-         * @param {string} search
-         * @throws {AppwriteException}
-         * @returns {Promise}
-         */
-        async list(queries?: string[], search?: string): Promise<Models.FunctionList> {
-            let path = '/functions';
-            let payload: Payload = {};
-
-            if (typeof queries !== 'undefined') {
-                payload['queries'] = queries;
-            }
-
-            if (typeof search !== 'undefined') {
-                payload['search'] = search;
-            }
+    /**
+     * List Functions
+     *
+     * Get a list of all the project's functions. You can use the query params to
+     * filter your results.
+     *
+     * @param {string[]} queries
+     * @param {string} search
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async list(queries?: string[], search?: string): Promise<Models.FunctionList> {
+        let path = '/functions';
+        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',
-            }, payload);
+        if (typeof search !== 'undefined') {
+            payload['search'] = search;
         }
 
-        /**
-         * Create Function
-         *
-         * Create a new function. You can pass a list of
-         * [permissions](/docs/permissions) to allow different project users or team
-         * with access to execute the function using the client API.
-         *
-         * @param {string} functionId
-         * @param {string} name
-         * @param {string} runtime
-         * @param {string[]} execute
-         * @param {string[]} events
-         * @param {string} schedule
-         * @param {number} timeout
-         * @param {boolean} enabled
-         * @throws {AppwriteException}
-         * @returns {Promise}
-         */
-        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"');
-            }
+        const uri = new URL(this.client.config.endpoint + path);
+        return await this.client.call('get', uri, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Create Function
+     *
+     * Create a new function. You can pass a list of
+     * [permissions](/docs/permissions) to allow different project users or team
+     * with access to execute the function using the client API.
+     *
+     * @param {string} functionId
+     * @param {string} name
+     * @param {string} runtime
+     * @param {string[]} execute
+     * @param {string[]} events
+     * @param {string} schedule
+     * @param {number} timeout
+     * @param {boolean} enabled
+     * @param {boolean} logging
+     * @param {string} entrypoint
+     * @param {string} commands
+     * @param {string} installationId
+     * @param {string} providerRepositoryId
+     * @param {string} providerBranch
+     * @param {boolean} providerSilentMode
+     * @param {string} providerRootDirectory
+     * @param {string} templateRepository
+     * @param {string} templateOwner
+     * @param {string} templateRootDirectory
+     * @param {string} templateBranch
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async create(functionId: string, name: string, runtime: string, execute?: string[], events?: string[], schedule?: string, timeout?: number, enabled?: boolean, logging?: boolean, entrypoint?: string, commands?: string, installationId?: string, providerRepositoryId?: string, providerBranch?: string, providerSilentMode?: boolean, providerRootDirectory?: string, templateRepository?: string, templateOwner?: string, templateRootDirectory?: string, templateBranch?: string): Promise<Models.Function> {
+        if (typeof functionId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "functionId"');
+        }
 
-            if (typeof name === 'undefined') {
-                throw new AppwriteException('Missing required parameter: "name"');
-            }
+        if (typeof name === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "name"');
+        }
 
-            if (typeof runtime === 'undefined') {
-                throw new AppwriteException('Missing required parameter: "runtime"');
-            }
+        if (typeof runtime === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "runtime"');
+        }
 
-            let path = '/functions';
-            let payload: Payload = {};
+        let path = '/functions';
+        let payload: Payload = {};
 
-            if (typeof functionId !== 'undefined') {
-                payload['functionId'] = functionId;
-            }
+        if (typeof functionId !== 'undefined') {
+            payload['functionId'] = functionId;
+        }
 
-            if (typeof name !== 'undefined') {
-                payload['name'] = name;
-            }
+        if (typeof name !== 'undefined') {
+            payload['name'] = name;
+        }
 
-            if (typeof execute !== 'undefined') {
-                payload['execute'] = execute;
-            }
+        if (typeof runtime !== 'undefined') {
+            payload['runtime'] = runtime;
+        }
 
-            if (typeof runtime !== 'undefined') {
-                payload['runtime'] = runtime;
-            }
+        if (typeof execute !== 'undefined') {
+            payload['execute'] = execute;
+        }
 
-            if (typeof events !== 'undefined') {
-                payload['events'] = events;
-            }
+        if (typeof events !== 'undefined') {
+            payload['events'] = events;
+        }
 
-            if (typeof schedule !== 'undefined') {
-                payload['schedule'] = schedule;
-            }
+        if (typeof schedule !== 'undefined') {
+            payload['schedule'] = schedule;
+        }
 
-            if (typeof timeout !== 'undefined') {
-                payload['timeout'] = timeout;
-            }
+        if (typeof timeout !== 'undefined') {
+            payload['timeout'] = timeout;
+        }
 
-            if (typeof enabled !== 'undefined') {
-                payload['enabled'] = enabled;
-            }
+        if (typeof enabled !== 'undefined') {
+            payload['enabled'] = enabled;
+        }
 
-            const uri = new URL(this.client.config.endpoint + path);
-            return await this.client.call('post', uri, {
-                'content-type': 'application/json',
-            }, payload);
+        if (typeof logging !== 'undefined') {
+            payload['logging'] = logging;
         }
 
-        /**
-         * List runtimes
-         *
-         * Get a list of all runtimes that are currently active on your instance.
-         *
-         * @throws {AppwriteException}
-         * @returns {Promise}
-         */
-        async listRuntimes(): Promise<Models.RuntimeList> {
-            let path = '/functions/runtimes';
-            let payload: Payload = {};
-
-            const uri = new URL(this.client.config.endpoint + path);
-            return await this.client.call('get', uri, {
-                'content-type': 'application/json',
-            }, payload);
+        if (typeof entrypoint !== 'undefined') {
+            payload['entrypoint'] = entrypoint;
         }
 
-        /**
-         * Get Functions Usage
-         *
-         *
-         * @param {string} range
-         * @throws {AppwriteException}
-         * @returns {Promise}
-         */
-        async getUsage(range?: string): Promise<Models.UsageFunctions> {
-            let path = '/functions/usage';
-            let payload: Payload = {};
-
-            if (typeof range !== 'undefined') {
-                payload['range'] = range;
-            }
+        if (typeof commands !== 'undefined') {
+            payload['commands'] = commands;
+        }
 
-            const uri = new URL(this.client.config.endpoint + path);
-            return await this.client.call('get', uri, {
-                'content-type': 'application/json',
-            }, payload);
+        if (typeof installationId !== 'undefined') {
+            payload['installationId'] = installationId;
         }
 
-        /**
-         * Get Function
-         *
-         * Get a function by its unique ID.
-         *
-         * @param {string} functionId
-         * @throws {AppwriteException}
-         * @returns {Promise}
-         */
-        async get(functionId: string): Promise<Models.Function> {
-            if (typeof functionId === 'undefined') {
-                throw new AppwriteException('Missing required parameter: "functionId"');
-            }
+        if (typeof providerRepositoryId !== 'undefined') {
+            payload['providerRepositoryId'] = providerRepositoryId;
+        }
 
-            let path = '/functions/{functionId}'.replace('{functionId}', functionId);
-            let payload: Payload = {};
+        if (typeof providerBranch !== 'undefined') {
+            payload['providerBranch'] = providerBranch;
+        }
 
-            const uri = new URL(this.client.config.endpoint + path);
-            return await this.client.call('get', uri, {
-                'content-type': 'application/json',
-            }, payload);
+        if (typeof providerSilentMode !== 'undefined') {
+            payload['providerSilentMode'] = providerSilentMode;
         }
 
-        /**
-         * Update Function
-         *
-         * Update function by its unique ID.
-         *
-         * @param {string} functionId
-         * @param {string} name
-         * @param {string[]} execute
-         * @param {string[]} events
-         * @param {string} schedule
-         * @param {number} timeout
-         * @param {boolean} enabled
-         * @throws {AppwriteException}
-         * @returns {Promise}
-         */
-        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"');
-            }
+        if (typeof providerRootDirectory !== 'undefined') {
+            payload['providerRootDirectory'] = providerRootDirectory;
+        }
 
-            if (typeof name === 'undefined') {
-                throw new AppwriteException('Missing required parameter: "name"');
-            }
+        if (typeof templateRepository !== 'undefined') {
+            payload['templateRepository'] = templateRepository;
+        }
 
-            let path = '/functions/{functionId}'.replace('{functionId}', functionId);
-            let payload: Payload = {};
+        if (typeof templateOwner !== 'undefined') {
+            payload['templateOwner'] = templateOwner;
+        }
 
-            if (typeof name !== 'undefined') {
-                payload['name'] = name;
-            }
+        if (typeof templateRootDirectory !== 'undefined') {
+            payload['templateRootDirectory'] = templateRootDirectory;
+        }
 
-            if (typeof execute !== 'undefined') {
-                payload['execute'] = execute;
-            }
+        if (typeof templateBranch !== 'undefined') {
+            payload['templateBranch'] = templateBranch;
+        }
 
-            if (typeof events !== 'undefined') {
-                payload['events'] = events;
-            }
+        const uri = new URL(this.client.config.endpoint + path);
+        return await this.client.call('post', uri, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * List runtimes
+     *
+     * Get a list of all runtimes that are currently active on your instance.
+     *
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async listRuntimes(): Promise<Models.RuntimeList> {
+        let path = '/functions/runtimes';
+        let payload: Payload = {};
+
+        const uri = new URL(this.client.config.endpoint + path);
+        return await this.client.call('get', uri, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Get Functions Usage
+     *
+     *
+     * @param {string} range
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async getUsage(range?: string): Promise<Models.UsageFunctions> {
+        let path = '/functions/usage';
+        let payload: Payload = {};
+
+        if (typeof range !== 'undefined') {
+            payload['range'] = range;
+        }
 
-            if (typeof schedule !== 'undefined') {
-                payload['schedule'] = schedule;
-            }
+        const uri = new URL(this.client.config.endpoint + path);
+        return await this.client.call('get', uri, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Get Function
+     *
+     * Get a function by its unique ID.
+     *
+     * @param {string} functionId
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async get(functionId: string): Promise<Models.Function> {
+        if (typeof functionId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "functionId"');
+        }
 
-            if (typeof timeout !== 'undefined') {
-                payload['timeout'] = timeout;
-            }
+        let path = '/functions/{functionId}'.replace('{functionId}', functionId);
+        let payload: Payload = {};
+
+        const uri = new URL(this.client.config.endpoint + path);
+        return await this.client.call('get', uri, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Update Function
+     *
+     * Update function by its unique ID.
+     *
+     * @param {string} functionId
+     * @param {string} name
+     * @param {string} runtime
+     * @param {string[]} execute
+     * @param {string[]} events
+     * @param {string} schedule
+     * @param {number} timeout
+     * @param {boolean} enabled
+     * @param {boolean} logging
+     * @param {string} entrypoint
+     * @param {string} commands
+     * @param {string} installationId
+     * @param {string} providerRepositoryId
+     * @param {string} providerBranch
+     * @param {boolean} providerSilentMode
+     * @param {string} providerRootDirectory
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async update(functionId: string, name: string, runtime: string, execute?: string[], events?: string[], schedule?: string, timeout?: number, enabled?: boolean, logging?: boolean, entrypoint?: string, commands?: string, installationId?: string, providerRepositoryId?: string, providerBranch?: string, providerSilentMode?: boolean, providerRootDirectory?: string): Promise<Models.Function> {
+        if (typeof functionId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "functionId"');
+        }
 
-            if (typeof enabled !== 'undefined') {
-                payload['enabled'] = enabled;
-            }
+        if (typeof name === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "name"');
+        }
 
-            const uri = new URL(this.client.config.endpoint + path);
-            return await this.client.call('put', uri, {
-                'content-type': 'application/json',
-            }, payload);
+        if (typeof runtime === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "runtime"');
         }
 
-        /**
-         * Delete Function
-         *
-         * Delete a function by its unique ID.
-         *
-         * @param {string} functionId
-         * @throws {AppwriteException}
-         * @returns {Promise}
-         */
-        async delete(functionId: string): Promise<{}> {
-            if (typeof functionId === 'undefined') {
-                throw new AppwriteException('Missing required parameter: "functionId"');
-            }
+        let path = '/functions/{functionId}'.replace('{functionId}', functionId);
+        let payload: Payload = {};
 
-            let path = '/functions/{functionId}'.replace('{functionId}', functionId);
-            let payload: Payload = {};
+        if (typeof name !== 'undefined') {
+            payload['name'] = name;
+        }
 
-            const uri = new URL(this.client.config.endpoint + path);
-            return await this.client.call('delete', uri, {
-                'content-type': 'application/json',
-            }, payload);
+        if (typeof runtime !== 'undefined') {
+            payload['runtime'] = runtime;
         }
 
-        /**
-         * List Deployments
-         *
-         * Get a list of all the project's code deployments. You can use the query
-         * params to filter your results.
-         *
-         * @param {string} functionId
-         * @param {string[]} queries
-         * @param {string} search
-         * @throws {AppwriteException}
-         * @returns {Promise}
-         */
-        async listDeployments(functionId: string, queries?: string[], search?: string): Promise<Models.DeploymentList> {
-            if (typeof functionId === 'undefined') {
-                throw new AppwriteException('Missing required parameter: "functionId"');
-            }
+        if (typeof execute !== 'undefined') {
+            payload['execute'] = execute;
+        }
 
-            let path = '/functions/{functionId}/deployments'.replace('{functionId}', functionId);
-            let payload: Payload = {};
+        if (typeof events !== 'undefined') {
+            payload['events'] = events;
+        }
 
-            if (typeof queries !== 'undefined') {
-                payload['queries'] = queries;
-            }
+        if (typeof schedule !== 'undefined') {
+            payload['schedule'] = schedule;
+        }
 
-            if (typeof search !== 'undefined') {
-                payload['search'] = search;
-            }
+        if (typeof timeout !== 'undefined') {
+            payload['timeout'] = timeout;
+        }
 
-            const uri = new URL(this.client.config.endpoint + path);
-            return await this.client.call('get', uri, {
-                'content-type': 'application/json',
-            }, payload);
+        if (typeof enabled !== 'undefined') {
+            payload['enabled'] = enabled;
         }
 
-        /**
-         * Create Deployment
-         *
-         * Create a new function code deployment. Use this endpoint to upload a new
-         * version of your code function. To execute your newly uploaded code, you'll
-         * need to update the function's deployment to use your new deployment UID.
-         * 
-         * This endpoint accepts a tar.gz file compressed with your code. Make sure to
-         * include any dependencies your code has within the compressed file. You can
-         * learn more about code packaging in the [Appwrite Cloud Functions
-         * tutorial](/docs/functions).
-         * 
-         * Use the "command" param to set the entry point used to execute your code.
-         *
-         * @param {string} functionId
-         * @param {string} entrypoint
-         * @param {File} code
-         * @param {boolean} activate
-         * @throws {AppwriteException}
-         * @returns {Promise}
-         */
-        async createDeployment(functionId: string, entrypoint: string, code: File, activate: boolean, onProgress = (progress: UploadProgress) => {}): Promise<Models.Deployment> {
-            if (typeof functionId === 'undefined') {
-                throw new AppwriteException('Missing required parameter: "functionId"');
-            }
+        if (typeof logging !== 'undefined') {
+            payload['logging'] = logging;
+        }
 
-            if (typeof entrypoint === 'undefined') {
-                throw new AppwriteException('Missing required parameter: "entrypoint"');
-            }
+        if (typeof entrypoint !== 'undefined') {
+            payload['entrypoint'] = entrypoint;
+        }
 
-            if (typeof code === 'undefined') {
-                throw new AppwriteException('Missing required parameter: "code"');
-            }
+        if (typeof commands !== 'undefined') {
+            payload['commands'] = commands;
+        }
 
-            if (typeof activate === 'undefined') {
-                throw new AppwriteException('Missing required parameter: "activate"');
-            }
+        if (typeof installationId !== 'undefined') {
+            payload['installationId'] = installationId;
+        }
 
-            let path = '/functions/{functionId}/deployments'.replace('{functionId}', functionId);
-            let payload: Payload = {};
+        if (typeof providerRepositoryId !== 'undefined') {
+            payload['providerRepositoryId'] = providerRepositoryId;
+        }
 
-            if (typeof entrypoint !== 'undefined') {
-                payload['entrypoint'] = entrypoint;
-            }
+        if (typeof providerBranch !== 'undefined') {
+            payload['providerBranch'] = providerBranch;
+        }
 
-            if (typeof code !== 'undefined') {
-                payload['code'] = code;
-            }
+        if (typeof providerSilentMode !== 'undefined') {
+            payload['providerSilentMode'] = providerSilentMode;
+        }
 
-            if (typeof activate !== 'undefined') {
-                payload['activate'] = activate;
-            }
+        if (typeof providerRootDirectory !== 'undefined') {
+            payload['providerRootDirectory'] = providerRootDirectory;
+        }
 
-            const uri = new URL(this.client.config.endpoint + path);
+        const uri = new URL(this.client.config.endpoint + path);
+        return await this.client.call('put', uri, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Delete Function
+     *
+     * Delete a function by its unique ID.
+     *
+     * @param {string} functionId
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async delete(functionId: string): Promise<{}> {
+        if (typeof functionId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "functionId"');
+        }
 
-            if(!(code instanceof File)) {
-                throw new AppwriteException('Parameter "code" has to be a File.');
-            }
+        let path = '/functions/{functionId}'.replace('{functionId}', functionId);
+        let payload: Payload = {};
+
+        const uri = new URL(this.client.config.endpoint + path);
+        return await this.client.call('delete', uri, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * List Deployments
+     *
+     * Get a list of all the project's code deployments. You can use the query
+     * params to filter your results.
+     *
+     * @param {string} functionId
+     * @param {string[]} queries
+     * @param {string} search
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async listDeployments(functionId: string, queries?: string[], search?: string): Promise<Models.DeploymentList> {
+        if (typeof functionId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "functionId"');
+        }
 
-            const size = code.size;
+        let path = '/functions/{functionId}/deployments'.replace('{functionId}', functionId);
+        let payload: Payload = {};
 
-            if (size <= Service.CHUNK_SIZE) {
-                return await this.client.call('post', uri, {
+        if (typeof queries !== 'undefined') {
+            payload['queries'] = queries;
+        }
 
-                    'content-type': 'multipart/form-data',
-                }, payload);
-            }
-            let id = undefined;
-            let response = undefined;
+        if (typeof search !== 'undefined') {
+            payload['search'] = search;
+        }
 
-            const headers: { [header: string]: string } = {
-                'content-type': 'multipart/form-data',
-            }
+        const uri = new URL(this.client.config.endpoint + path);
+        return await this.client.call('get', uri, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Create Deployment
+     *
+     * Create a new function code deployment. Use this endpoint to upload a new
+     * version of your code function. To execute your newly uploaded code, you'll
+     * need to update the function's deployment to use your new deployment UID.
+     * 
+     * This endpoint accepts a tar.gz file compressed with your code. Make sure to
+     * include any dependencies your code has within the compressed file. You can
+     * learn more about code packaging in the [Appwrite Cloud Functions
+     * tutorial](/docs/functions).
+     * 
+     * Use the "command" param to set the entrypoint used to execute your code.
+     *
+     * @param {string} functionId
+     * @param {File} code
+     * @param {boolean} activate
+     * @param {string} entrypoint
+     * @param {string} commands
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async createDeployment(functionId: string, code: File, activate: boolean, entrypoint?: string, commands?: string, onProgress = (progress: UploadProgress) => {}): Promise<Models.Deployment> {
+        if (typeof functionId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "functionId"');
+        }
 
-            let counter = 0;
-            const totalCounters = Math.ceil(size / Service.CHUNK_SIZE);
+        if (typeof code === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "code"');
+        }
 
-            for (counter; counter < totalCounters; counter++) {
-                const start = (counter * Service.CHUNK_SIZE);
-                const end = Math.min((((counter * Service.CHUNK_SIZE) + Service.CHUNK_SIZE) - 1), size);
+        if (typeof activate === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "activate"');
+        }
 
-                headers['content-range'] = 'bytes ' + start + '-' + end + '/' + size
+        let path = '/functions/{functionId}/deployments'.replace('{functionId}', functionId);
+        let payload: Payload = {};
 
-                if (id) {
-                    headers['x-appwrite-id'] = id;
-                }
+        if (typeof entrypoint !== 'undefined') {
+            payload['entrypoint'] = entrypoint;
+        }
 
-                const stream = code.slice(start, end + 1);
-                payload['code'] = new File([stream], code.name);
+        if (typeof commands !== 'undefined') {
+            payload['commands'] = commands;
+        }
 
-                response = await this.client.call('post', uri, headers, payload);
+        if (typeof code !== 'undefined') {
+            payload['code'] = code;
+        }
 
-                if (!id) {
-                    id = response['$id'];
-                }
+        if (typeof activate !== 'undefined') {
+            payload['activate'] = activate;
+        }
 
-                if (onProgress) {
-                    onProgress({
-                        $id: response.$id,
-                        progress: Math.min((counter + 1) * Service.CHUNK_SIZE - 1, size) / size * 100,
-                        sizeUploaded: end,
-                        chunksTotal: response.chunksTotal,
-                        chunksUploaded: response.chunksUploaded
-                    });
-                }
-            }
+        const uri = new URL(this.client.config.endpoint + path);
 
-            return response;
-        }
-
-        /**
-         * Get Deployment
-         *
-         * Get a code deployment by its unique ID.
-         *
-         * @param {string} functionId
-         * @param {string} deploymentId
-         * @throws {AppwriteException}
-         * @returns {Promise}
-         */
-        async getDeployment(functionId: string, deploymentId: string): Promise<Models.Deployment> {
-            if (typeof functionId === 'undefined') {
-                throw new AppwriteException('Missing required parameter: "functionId"');
-            }
+        if(!(code instanceof File)) {
+            throw new AppwriteException('Parameter "code" has to be a File.');
+        }
 
-            if (typeof deploymentId === 'undefined') {
-                throw new AppwriteException('Missing required parameter: "deploymentId"');
-            }
+        const size = code.size;
 
-            let path = '/functions/{functionId}/deployments/{deploymentId}'.replace('{functionId}', functionId).replace('{deploymentId}', deploymentId);
-            let payload: Payload = {};
+        if (size <= Service.CHUNK_SIZE) {
+            return await this.client.call('post', uri, {
 
-            const uri = new URL(this.client.config.endpoint + path);
-            return await this.client.call('get', uri, {
-                'content-type': 'application/json',
+                'content-type': 'multipart/form-data',
             }, payload);
         }
+        let id = undefined;
+        let response = undefined;
 
-        /**
-         * Update Function Deployment
-         *
-         * Update the function code deployment ID using the unique function ID. Use
-         * this endpoint to switch the code deployment that should be executed by the
-         * execution endpoint.
-         *
-         * @param {string} functionId
-         * @param {string} deploymentId
-         * @throws {AppwriteException}
-         * @returns {Promise}
-         */
-        async updateDeployment(functionId: string, deploymentId: string): Promise<Models.Function> {
-            if (typeof functionId === 'undefined') {
-                throw new AppwriteException('Missing required parameter: "functionId"');
-            }
-
-            if (typeof deploymentId === 'undefined') {
-                throw new AppwriteException('Missing required parameter: "deploymentId"');
-            }
+        const headers: { [header: string]: string } = {
+            'content-type': 'multipart/form-data',
+        }
 
-            let path = '/functions/{functionId}/deployments/{deploymentId}'.replace('{functionId}', functionId).replace('{deploymentId}', deploymentId);
-            let payload: Payload = {};
+        let counter = 0;
+        const totalCounters = Math.ceil(size / Service.CHUNK_SIZE);
 
-            const uri = new URL(this.client.config.endpoint + path);
-            return await this.client.call('patch', uri, {
-                'content-type': 'application/json',
-            }, payload);
-        }
+        for (counter; counter < totalCounters; counter++) {
+            const start = (counter * Service.CHUNK_SIZE);
+            const end = Math.min((((counter * Service.CHUNK_SIZE) + Service.CHUNK_SIZE) - 1), size);
 
-        /**
-         * Delete Deployment
-         *
-         * Delete a code deployment by its unique ID.
-         *
-         * @param {string} functionId
-         * @param {string} deploymentId
-         * @throws {AppwriteException}
-         * @returns {Promise}
-         */
-        async deleteDeployment(functionId: string, deploymentId: string): Promise<{}> {
-            if (typeof functionId === 'undefined') {
-                throw new AppwriteException('Missing required parameter: "functionId"');
-            }
+            headers['content-range'] = 'bytes ' + start + '-' + end + '/' + size
 
-            if (typeof deploymentId === 'undefined') {
-                throw new AppwriteException('Missing required parameter: "deploymentId"');
+            if (id) {
+                headers['x-appwrite-id'] = id;
             }
 
-            let path = '/functions/{functionId}/deployments/{deploymentId}'.replace('{functionId}', functionId).replace('{deploymentId}', deploymentId);
-            let payload: Payload = {};
+            const stream = code.slice(start, end + 1);
+            payload['code'] = new File([stream], code.name);
 
-            const uri = new URL(this.client.config.endpoint + path);
-            return await this.client.call('delete', uri, {
-                'content-type': 'application/json',
-            }, payload);
-        }
+            response = await this.client.call('post', uri, headers, payload);
 
-        /**
-         * Create Build
-         *
-         *
-         * @param {string} functionId
-         * @param {string} deploymentId
-         * @param {string} buildId
-         * @throws {AppwriteException}
-         * @returns {Promise}
-         */
-        async createBuild(functionId: string, deploymentId: string, buildId: string): Promise<{}> {
-            if (typeof functionId === 'undefined') {
-                throw new AppwriteException('Missing required parameter: "functionId"');
+            if (!id) {
+                id = response['$id'];
             }
 
-            if (typeof deploymentId === 'undefined') {
-                throw new AppwriteException('Missing required parameter: "deploymentId"');
+            if (onProgress) {
+                onProgress({
+                    $id: response.$id,
+                    progress: Math.min((counter + 1) * Service.CHUNK_SIZE - 1, size) / size * 100,
+                    sizeUploaded: end,
+                    chunksTotal: response.chunksTotal,
+                    chunksUploaded: response.chunksUploaded
+                });
             }
+        }
 
-            if (typeof buildId === 'undefined') {
-                throw new AppwriteException('Missing required parameter: "buildId"');
-            }
+        return response;
+    }
+
+    /**
+     * Get Deployment
+     *
+     * Get a code deployment by its unique ID.
+     *
+     * @param {string} functionId
+     * @param {string} deploymentId
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async getDeployment(functionId: string, deploymentId: string): Promise<Models.Deployment> {
+        if (typeof functionId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "functionId"');
+        }
 
-            let path = '/functions/{functionId}/deployments/{deploymentId}/builds/{buildId}'.replace('{functionId}', functionId).replace('{deploymentId}', deploymentId).replace('{buildId}', buildId);
-            let payload: Payload = {};
+        if (typeof deploymentId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "deploymentId"');
+        }
 
-            const uri = new URL(this.client.config.endpoint + path);
-            return await this.client.call('post', uri, {
-                'content-type': 'application/json',
-            }, payload);
+        let path = '/functions/{functionId}/deployments/{deploymentId}'.replace('{functionId}', functionId).replace('{deploymentId}', deploymentId);
+        let payload: Payload = {};
+
+        const uri = new URL(this.client.config.endpoint + path);
+        return await this.client.call('get', uri, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Update Function Deployment
+     *
+     * Update the function code deployment ID using the unique function ID. Use
+     * this endpoint to switch the code deployment that should be executed by the
+     * execution endpoint.
+     *
+     * @param {string} functionId
+     * @param {string} deploymentId
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async updateDeployment(functionId: string, deploymentId: string): Promise<Models.Function> {
+        if (typeof functionId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "functionId"');
         }
 
-        /**
-         * List Executions
-         *
-         * Get a list of all the current user function execution logs. You can use the
-         * query params to filter your results.
-         *
-         * @param {string} functionId
-         * @param {string[]} queries
-         * @param {string} search
-         * @throws {AppwriteException}
-         * @returns {Promise}
-         */
-        async listExecutions(functionId: string, queries?: string[], search?: string): Promise<Models.ExecutionList> {
-            if (typeof functionId === 'undefined') {
-                throw new AppwriteException('Missing required parameter: "functionId"');
-            }
+        if (typeof deploymentId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "deploymentId"');
+        }
 
-            let path = '/functions/{functionId}/executions'.replace('{functionId}', functionId);
-            let payload: Payload = {};
+        let path = '/functions/{functionId}/deployments/{deploymentId}'.replace('{functionId}', functionId).replace('{deploymentId}', deploymentId);
+        let payload: Payload = {};
+
+        const uri = new URL(this.client.config.endpoint + path);
+        return await this.client.call('patch', uri, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Delete Deployment
+     *
+     * Delete a code deployment by its unique ID.
+     *
+     * @param {string} functionId
+     * @param {string} deploymentId
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async deleteDeployment(functionId: string, deploymentId: string): Promise<{}> {
+        if (typeof functionId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "functionId"');
+        }
 
-            if (typeof queries !== 'undefined') {
-                payload['queries'] = queries;
-            }
+        if (typeof deploymentId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "deploymentId"');
+        }
 
-            if (typeof search !== 'undefined') {
-                payload['search'] = search;
-            }
+        let path = '/functions/{functionId}/deployments/{deploymentId}'.replace('{functionId}', functionId).replace('{deploymentId}', deploymentId);
+        let payload: Payload = {};
+
+        const uri = new URL(this.client.config.endpoint + path);
+        return await this.client.call('delete', uri, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Create Build
+     *
+     *
+     * @param {string} functionId
+     * @param {string} deploymentId
+     * @param {string} buildId
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async createBuild(functionId: string, deploymentId: string, buildId: string): Promise<{}> {
+        if (typeof functionId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "functionId"');
+        }
 
-            const uri = new URL(this.client.config.endpoint + path);
-            return await this.client.call('get', uri, {
-                'content-type': 'application/json',
-            }, payload);
+        if (typeof deploymentId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "deploymentId"');
         }
 
-        /**
-         * Create Execution
-         *
-         * Trigger a function execution. The returned object will return you the
-         * current execution status. You can ping the `Get Execution` endpoint to get
-         * updates on the current execution status. Once this endpoint is called, your
-         * function execution process will start asynchronously.
-         *
-         * @param {string} functionId
-         * @param {string} data
-         * @param {boolean} async
-         * @throws {AppwriteException}
-         * @returns {Promise}
-         */
-        async createExecution(functionId: string, data?: string, async?: boolean): Promise<Models.Execution> {
-            if (typeof functionId === 'undefined') {
-                throw new AppwriteException('Missing required parameter: "functionId"');
-            }
+        if (typeof buildId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "buildId"');
+        }
 
-            let path = '/functions/{functionId}/executions'.replace('{functionId}', functionId);
-            let payload: Payload = {};
+        let path = '/functions/{functionId}/deployments/{deploymentId}/builds/{buildId}'.replace('{functionId}', functionId).replace('{deploymentId}', deploymentId).replace('{buildId}', buildId);
+        let payload: Payload = {};
+
+        const uri = new URL(this.client.config.endpoint + path);
+        return await this.client.call('post', uri, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Download Deployment
+     *
+     *
+     * @param {string} functionId
+     * @param {string} deploymentId
+     * @throws {AppwriteException}
+     * @returns {URL}
+    */
+    downloadDeployment(functionId: string, deploymentId: string): URL {
+        if (typeof functionId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "functionId"');
+        }
 
-            if (typeof data !== 'undefined') {
-                payload['data'] = data;
-            }
+        if (typeof deploymentId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "deploymentId"');
+        }
 
-            if (typeof async !== 'undefined') {
-                payload['async'] = async;
-            }
+        let path = '/functions/{functionId}/deployments/{deploymentId}/download'.replace('{functionId}', functionId).replace('{deploymentId}', deploymentId);
+        let payload: Payload = {};
 
-            const uri = new URL(this.client.config.endpoint + path);
-            return await this.client.call('post', uri, {
-                'content-type': 'application/json',
-            }, payload);
+        const uri = new URL(this.client.config.endpoint + path);
+        payload['project'] = this.client.config.project;
+
+
+        for (const [key, value] of Object.entries(Service.flatten(payload))) {
+            uri.searchParams.append(key, value);
+        }
+        return uri;
+    }
+
+    /**
+     * List Executions
+     *
+     * Get a list of all the current user function execution logs. You can use the
+     * query params to filter your results.
+     *
+     * @param {string} functionId
+     * @param {string[]} queries
+     * @param {string} search
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async listExecutions(functionId: string, queries?: string[], search?: string): Promise<Models.ExecutionList> {
+        if (typeof functionId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "functionId"');
         }
 
-        /**
-         * Get Execution
-         *
-         * Get a function execution log by its unique ID.
-         *
-         * @param {string} functionId
-         * @param {string} executionId
-         * @throws {AppwriteException}
-         * @returns {Promise}
-         */
-        async getExecution(functionId: string, executionId: string): Promise<Models.Execution> {
-            if (typeof functionId === 'undefined') {
-                throw new AppwriteException('Missing required parameter: "functionId"');
-            }
+        let path = '/functions/{functionId}/executions'.replace('{functionId}', functionId);
+        let payload: Payload = {};
 
-            if (typeof executionId === 'undefined') {
-                throw new AppwriteException('Missing required parameter: "executionId"');
-            }
+        if (typeof queries !== 'undefined') {
+            payload['queries'] = queries;
+        }
 
-            let path = '/functions/{functionId}/executions/{executionId}'.replace('{functionId}', functionId).replace('{executionId}', executionId);
-            let payload: Payload = {};
+        if (typeof search !== 'undefined') {
+            payload['search'] = search;
+        }
 
-            const uri = new URL(this.client.config.endpoint + path);
-            return await this.client.call('get', uri, {
-                'content-type': 'application/json',
-            }, payload);
+        const uri = new URL(this.client.config.endpoint + path);
+        return await this.client.call('get', uri, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Create Execution
+     *
+     * Trigger a function execution. The returned object will return you the
+     * current execution status. You can ping the `Get Execution` endpoint to get
+     * updates on the current execution status. Once this endpoint is called, your
+     * function execution process will start asynchronously.
+     *
+     * @param {string} functionId
+     * @param {string} body
+     * @param {boolean} async
+     * @param {string} path
+     * @param {string} method
+     * @param {object} headers
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async createExecution(functionId: string, body?: string, async?: boolean, path?: string, method?: string, headers?: object): Promise<Models.Execution> {
+        if (typeof functionId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "functionId"');
         }
 
-        /**
-         * Get Function Usage
-         *
-         *
-         * @param {string} functionId
-         * @param {string} range
-         * @throws {AppwriteException}
-         * @returns {Promise}
-         */
-        async getFunctionUsage(functionId: string, range?: string): Promise<Models.UsageFunctions> {
-            if (typeof functionId === 'undefined') {
-                throw new AppwriteException('Missing required parameter: "functionId"');
-            }
+        let _path = '/functions/{functionId}/executions'.replace('{functionId}', functionId);
+        let payload: Payload = {};
 
-            let path = '/functions/{functionId}/usage'.replace('{functionId}', functionId);
-            let payload: Payload = {};
+        if (typeof body !== 'undefined') {
+            payload['body'] = body;
+        }
 
-            if (typeof range !== 'undefined') {
-                payload['range'] = range;
-            }
+        if (typeof async !== 'undefined') {
+            payload['async'] = async;
+        }
 
-            const uri = new URL(this.client.config.endpoint + path);
-            return await this.client.call('get', uri, {
-                'content-type': 'application/json',
-            }, payload);
+        if (typeof path !== 'undefined') {
+            payload['path'] = path;
         }
 
-        /**
-         * List Variables
-         *
-         * Get a list of all variables of a specific function.
-         *
-         * @param {string} functionId
-         * @throws {AppwriteException}
-         * @returns {Promise}
-         */
-        async listVariables(functionId: string): Promise<Models.VariableList> {
-            if (typeof functionId === 'undefined') {
-                throw new AppwriteException('Missing required parameter: "functionId"');
-            }
+        if (typeof method !== 'undefined') {
+            payload['method'] = method;
+        }
 
-            let path = '/functions/{functionId}/variables'.replace('{functionId}', functionId);
-            let payload: Payload = {};
+        if (typeof headers !== 'undefined') {
+            payload['headers'] = headers;
+        }
 
-            const uri = new URL(this.client.config.endpoint + path);
-            return await this.client.call('get', uri, {
-                'content-type': 'application/json',
-            }, payload);
+        const uri = new URL(this.client.config.endpoint + _path);
+        return await this.client.call('post', uri, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Get Execution
+     *
+     * Get a function execution log by its unique ID.
+     *
+     * @param {string} functionId
+     * @param {string} executionId
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async getExecution(functionId: string, executionId: string): Promise<Models.Execution> {
+        if (typeof functionId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "functionId"');
         }
 
-        /**
-         * Create Variable
-         *
-         * Create a new function variable. These variables can be accessed within
-         * function in the `env` object under the request variable.
-         *
-         * @param {string} functionId
-         * @param {string} key
-         * @param {string} value
-         * @throws {AppwriteException}
-         * @returns {Promise}
-         */
-        async createVariable(functionId: string, key: string, value: string): Promise<Models.Variable> {
-            if (typeof functionId === 'undefined') {
-                throw new AppwriteException('Missing required parameter: "functionId"');
-            }
+        if (typeof executionId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "executionId"');
+        }
 
-            if (typeof key === 'undefined') {
-                throw new AppwriteException('Missing required parameter: "key"');
-            }
+        let path = '/functions/{functionId}/executions/{executionId}'.replace('{functionId}', functionId).replace('{executionId}', executionId);
+        let payload: Payload = {};
+
+        const uri = new URL(this.client.config.endpoint + path);
+        return await this.client.call('get', uri, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Get Function Usage
+     *
+     *
+     * @param {string} functionId
+     * @param {string} range
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async getFunctionUsage(functionId: string, range?: string): Promise<Models.UsageFunctions> {
+        if (typeof functionId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "functionId"');
+        }
 
-            if (typeof value === 'undefined') {
-                throw new AppwriteException('Missing required parameter: "value"');
-            }
+        let path = '/functions/{functionId}/usage'.replace('{functionId}', functionId);
+        let payload: Payload = {};
 
-            let path = '/functions/{functionId}/variables'.replace('{functionId}', functionId);
-            let payload: Payload = {};
+        if (typeof range !== 'undefined') {
+            payload['range'] = range;
+        }
 
-            if (typeof key !== 'undefined') {
-                payload['key'] = key;
-            }
+        const uri = new URL(this.client.config.endpoint + path);
+        return await this.client.call('get', uri, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * List Variables
+     *
+     * Get a list of all variables of a specific function.
+     *
+     * @param {string} functionId
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async listVariables(functionId: string): Promise<Models.VariableList> {
+        if (typeof functionId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "functionId"');
+        }
 
-            if (typeof value !== 'undefined') {
-                payload['value'] = value;
-            }
+        let path = '/functions/{functionId}/variables'.replace('{functionId}', functionId);
+        let payload: Payload = {};
+
+        const uri = new URL(this.client.config.endpoint + path);
+        return await this.client.call('get', uri, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Create Variable
+     *
+     * Create a new function environment variable. These variables can be accessed
+     * in the function at runtime as environment variables.
+     *
+     * @param {string} functionId
+     * @param {string} key
+     * @param {string} value
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async createVariable(functionId: string, key: string, value: string): Promise<Models.Variable> {
+        if (typeof functionId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "functionId"');
+        }
 
-            const uri = new URL(this.client.config.endpoint + path);
-            return await this.client.call('post', uri, {
-                'content-type': 'application/json',
-            }, payload);
+        if (typeof key === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "key"');
         }
 
-        /**
-         * Get Variable
-         *
-         * Get a variable by its unique ID.
-         *
-         * @param {string} functionId
-         * @param {string} variableId
-         * @throws {AppwriteException}
-         * @returns {Promise}
-         */
-        async getVariable(functionId: string, variableId: string): Promise<Models.Variable> {
-            if (typeof functionId === 'undefined') {
-                throw new AppwriteException('Missing required parameter: "functionId"');
-            }
+        if (typeof value === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "value"');
+        }
 
-            if (typeof variableId === 'undefined') {
-                throw new AppwriteException('Missing required parameter: "variableId"');
-            }
+        let path = '/functions/{functionId}/variables'.replace('{functionId}', functionId);
+        let payload: Payload = {};
 
-            let path = '/functions/{functionId}/variables/{variableId}'.replace('{functionId}', functionId).replace('{variableId}', variableId);
-            let payload: Payload = {};
+        if (typeof key !== 'undefined') {
+            payload['key'] = key;
+        }
 
-            const uri = new URL(this.client.config.endpoint + path);
-            return await this.client.call('get', uri, {
-                'content-type': 'application/json',
-            }, payload);
+        if (typeof value !== 'undefined') {
+            payload['value'] = value;
         }
 
-        /**
-         * Update Variable
-         *
-         * Update variable by its unique ID.
-         *
-         * @param {string} functionId
-         * @param {string} variableId
-         * @param {string} key
-         * @param {string} value
-         * @throws {AppwriteException}
-         * @returns {Promise}
-         */
-        async updateVariable(functionId: string, variableId: string, key: string, value?: string): Promise<Models.Variable> {
-            if (typeof functionId === 'undefined') {
-                throw new AppwriteException('Missing required parameter: "functionId"');
-            }
+        const uri = new URL(this.client.config.endpoint + path);
+        return await this.client.call('post', uri, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Get Variable
+     *
+     * Get a variable by its unique ID.
+     *
+     * @param {string} functionId
+     * @param {string} variableId
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async getVariable(functionId: string, variableId: string): Promise<Models.Variable> {
+        if (typeof functionId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "functionId"');
+        }
 
-            if (typeof variableId === 'undefined') {
-                throw new AppwriteException('Missing required parameter: "variableId"');
-            }
+        if (typeof variableId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "variableId"');
+        }
 
-            if (typeof key === 'undefined') {
-                throw new AppwriteException('Missing required parameter: "key"');
-            }
+        let path = '/functions/{functionId}/variables/{variableId}'.replace('{functionId}', functionId).replace('{variableId}', variableId);
+        let payload: Payload = {};
+
+        const uri = new URL(this.client.config.endpoint + path);
+        return await this.client.call('get', uri, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Update Variable
+     *
+     * Update variable by its unique ID.
+     *
+     * @param {string} functionId
+     * @param {string} variableId
+     * @param {string} key
+     * @param {string} value
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async updateVariable(functionId: string, variableId: string, key: string, value?: string): Promise<Models.Variable> {
+        if (typeof functionId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "functionId"');
+        }
 
-            let path = '/functions/{functionId}/variables/{variableId}'.replace('{functionId}', functionId).replace('{variableId}', variableId);
-            let payload: Payload = {};
+        if (typeof variableId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "variableId"');
+        }
 
-            if (typeof key !== 'undefined') {
-                payload['key'] = key;
-            }
+        if (typeof key === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "key"');
+        }
 
-            if (typeof value !== 'undefined') {
-                payload['value'] = value;
-            }
+        let path = '/functions/{functionId}/variables/{variableId}'.replace('{functionId}', functionId).replace('{variableId}', variableId);
+        let payload: Payload = {};
 
-            const uri = new URL(this.client.config.endpoint + path);
-            return await this.client.call('put', uri, {
-                'content-type': 'application/json',
-            }, payload);
+        if (typeof key !== 'undefined') {
+            payload['key'] = key;
         }
 
-        /**
-         * Delete Variable
-         *
-         * Delete a variable by its unique ID.
-         *
-         * @param {string} functionId
-         * @param {string} variableId
-         * @throws {AppwriteException}
-         * @returns {Promise}
-         */
-        async deleteVariable(functionId: string, variableId: string): Promise<{}> {
-            if (typeof functionId === 'undefined') {
-                throw new AppwriteException('Missing required parameter: "functionId"');
-            }
-
-            if (typeof variableId === 'undefined') {
-                throw new AppwriteException('Missing required parameter: "variableId"');
-            }
+        if (typeof value !== 'undefined') {
+            payload['value'] = value;
+        }
 
-            let path = '/functions/{functionId}/variables/{variableId}'.replace('{functionId}', functionId).replace('{variableId}', variableId);
-            let payload: Payload = {};
+        const uri = new URL(this.client.config.endpoint + path);
+        return await this.client.call('put', uri, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Delete Variable
+     *
+     * Delete a variable by its unique ID.
+     *
+     * @param {string} functionId
+     * @param {string} variableId
+     * @throws {AppwriteException}
+     * @returns {Promise}
+    */
+    async deleteVariable(functionId: string, variableId: string): Promise<{}> {
+        if (typeof functionId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "functionId"');
+        }
 
-            const uri = new URL(this.client.config.endpoint + path);
-            return await this.client.call('delete', uri, {
-                'content-type': 'application/json',
-            }, payload);
+        if (typeof variableId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "variableId"');
         }
+
+        let path = '/functions/{functionId}/variables/{variableId}'.replace('{functionId}', functionId).replace('{variableId}', variableId);
+        let payload: Payload = {};
+
+        const uri = new URL(this.client.config.endpoint + path);
+        return await this.client.call('delete', uri, {
+            'content-type': 'application/json',
+        }, payload);
+    }
 };