@appwrite.io/console 1.10.0 → 2.1.0

package/src/services/functions.ts

@@ -1,9 +1,11 @@
 import { Service } from '../service';
 import { AppwriteException, Client, type Payload, UploadProgress } from '../client';
 import type { Models } from '../models';
+
 import { Runtime } from '../enums/runtime';
-import { FunctionUsageRange } from '../enums/function-usage-range';
-import { VCSDeploymentType } from '../enums/v-c-s-deployment-type';
+import { UsageRange } from '../enums/usage-range';
+import { TemplateReferenceType } from '../enums/template-reference-type';
+import { VCSReferenceType } from '../enums/vcs-reference-type';
 import { DeploymentDownloadType } from '../enums/deployment-download-type';
 import { ExecutionMethod } from '../enums/execution-method';
 
@@ -15,14 +17,47 @@ export class Functions {
     }
 
     /**
-     * Get a list of all the project's functions. You can use the query params to filter your results.
+     * Get a list of all the project's functions. You can use the query params to filter your results.
+     *
+     * @param {string[]} params.queries - Array of query strings generated using the Query class provided by the SDK. [Learn more about queries](https://appwrite.io/docs/queries). Maximum of 100 queries are allowed, each 4096 characters long. You may filter on the following attributes: name, enabled, runtime, deploymentId, schedule, scheduleNext, schedulePrevious, timeout, entrypoint, commands, installationId
+     * @param {string} params.search - Search term to filter your list results. Max length: 256 chars.
+     * @param {boolean} params.total - When set to false, the total count returned will be 0 and will not be calculated.
+     * @throws {AppwriteException}
+     * @returns {Promise<Models.FunctionList>}
+     */
+    list(params?: { queries?: string[], search?: string, total?: boolean  }): Promise<Models.FunctionList>;
+    /**
+     * 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
+     * @param {string[]} queries - Array of query strings generated using the Query class provided by the SDK. [Learn more about queries](https://appwrite.io/docs/queries). Maximum of 100 queries are allowed, each 4096 characters long. You may filter on the following attributes: name, enabled, runtime, deploymentId, schedule, scheduleNext, schedulePrevious, timeout, entrypoint, commands, installationId
+     * @param {string} search - Search term to filter your list results. Max length: 256 chars.
+     * @param {boolean} total - When set to false, the total count returned will be 0 and will not be calculated.
      * @throws {AppwriteException}
      * @returns {Promise<Models.FunctionList>}
+     * @deprecated Use the object parameter style method for a better developer experience.
      */
-    list(queries?: string[], search?: string): Promise<Models.FunctionList> {
+    list(queries?: string[], search?: string, total?: boolean): Promise<Models.FunctionList>;
+    list(
+        paramsOrFirst?: { queries?: string[], search?: string, total?: boolean } | string[],
+        ...rest: [(string)?, (boolean)?]    
+    ): Promise<Models.FunctionList> {
+        let params: { queries?: string[], search?: string, total?: boolean };
+        
+        if (!paramsOrFirst || (paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst))) {
+            params = (paramsOrFirst || {}) as { queries?: string[], search?: string, total?: boolean };
+        } else {
+            params = {
+                queries: paramsOrFirst as string[],
+                search: rest[0] as string,
+                total: rest[1] as boolean            
+            };
+        }
+        
+        const queries = params.queries;
+        const search = params.search;
+        const total = params.total;
+
+
         const apiPath = '/functions';
         const payload: Payload = {};
         if (typeof queries !== 'undefined') {
@@ -31,6 +66,9 @@ export class Functions {
         if (typeof search !== 'undefined') {
             payload['search'] = search;
         }
+        if (typeof total !== 'undefined') {
+            payload['total'] = total;
+        }
         const uri = new URL(this.client.config.endpoint + apiPath);
 
         const apiHeaders: { [header: string]: string } = {
@@ -47,28 +85,104 @@ export class Functions {
     /**
      * Create a new function. You can pass a list of [permissions](https://appwrite.io/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 {Runtime} 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[]} scopes
-     * @param {string} installationId
-     * @param {string} providerRepositoryId
-     * @param {string} providerBranch
-     * @param {boolean} providerSilentMode
-     * @param {string} providerRootDirectory
-     * @param {string} specification
+     * @param {string} params.functionId - Function ID. Choose a custom ID or generate a random ID with `ID.unique()`. Valid chars are a-z, A-Z, 0-9, period, hyphen, and underscore. Can't start with a special char. Max length is 36 chars.
+     * @param {string} params.name - Function name. Max length: 128 chars.
+     * @param {Runtime} params.runtime - Execution runtime.
+     * @param {string[]} params.execute - An array of role strings with execution permissions. By default no user is granted with any execute permissions. [learn more about roles](https://appwrite.io/docs/permissions#permission-roles). Maximum of 100 roles are allowed, each 64 characters long.
+     * @param {string[]} params.events - Events list. Maximum of 100 events are allowed.
+     * @param {string} params.schedule - Schedule CRON syntax.
+     * @param {number} params.timeout - Function maximum execution time in seconds.
+     * @param {boolean} params.enabled - Is function enabled? When set to 'disabled', users cannot access the function but Server SDKs with and API key can still access the function. No data is lost when this is toggled.
+     * @param {boolean} params.logging - When disabled, executions will exclude logs and errors, and will be slightly faster.
+     * @param {string} params.entrypoint - Entrypoint File. This path is relative to the "providerRootDirectory".
+     * @param {string} params.commands - Build Commands.
+     * @param {string[]} params.scopes - List of scopes allowed for API key auto-generated for every execution. Maximum of 100 scopes are allowed.
+     * @param {string} params.installationId - Appwrite Installation ID for VCS (Version Control System) deployment.
+     * @param {string} params.providerRepositoryId - Repository ID of the repo linked to the function.
+     * @param {string} params.providerBranch - Production branch for the repo linked to the function.
+     * @param {boolean} params.providerSilentMode - Is the VCS (Version Control System) connection in silent mode for the repo linked to the function? In silent mode, comments will not be made on commits and pull requests.
+     * @param {string} params.providerRootDirectory - Path to function code in the linked repo.
+     * @param {string} params.specification - Runtime specification for the function and builds.
+     * @throws {AppwriteException}
+     * @returns {Promise<Models.Function>}
+     */
+    create(params: { functionId: string, name: string, runtime: Runtime, execute?: string[], events?: string[], schedule?: string, timeout?: number, enabled?: boolean, logging?: boolean, entrypoint?: string, commands?: string, scopes?: string[], installationId?: string, providerRepositoryId?: string, providerBranch?: string, providerSilentMode?: boolean, providerRootDirectory?: string, specification?: string  }): Promise<Models.Function>;
+    /**
+     * Create a new function. You can pass a list of [permissions](https://appwrite.io/docs/permissions) to allow different project users or team with access to execute the function using the client API.
+     *
+     * @param {string} functionId - Function ID. Choose a custom ID or generate a random ID with `ID.unique()`. Valid chars are a-z, A-Z, 0-9, period, hyphen, and underscore. Can't start with a special char. Max length is 36 chars.
+     * @param {string} name - Function name. Max length: 128 chars.
+     * @param {Runtime} runtime - Execution runtime.
+     * @param {string[]} execute - An array of role strings with execution permissions. By default no user is granted with any execute permissions. [learn more about roles](https://appwrite.io/docs/permissions#permission-roles). Maximum of 100 roles are allowed, each 64 characters long.
+     * @param {string[]} events - Events list. Maximum of 100 events are allowed.
+     * @param {string} schedule - Schedule CRON syntax.
+     * @param {number} timeout - Function maximum execution time in seconds.
+     * @param {boolean} enabled - Is function enabled? When set to 'disabled', users cannot access the function but Server SDKs with and API key can still access the function. No data is lost when this is toggled.
+     * @param {boolean} logging - When disabled, executions will exclude logs and errors, and will be slightly faster.
+     * @param {string} entrypoint - Entrypoint File. This path is relative to the "providerRootDirectory".
+     * @param {string} commands - Build Commands.
+     * @param {string[]} scopes - List of scopes allowed for API key auto-generated for every execution. Maximum of 100 scopes are allowed.
+     * @param {string} installationId - Appwrite Installation ID for VCS (Version Control System) deployment.
+     * @param {string} providerRepositoryId - Repository ID of the repo linked to the function.
+     * @param {string} providerBranch - Production branch for the repo linked to the function.
+     * @param {boolean} providerSilentMode - Is the VCS (Version Control System) connection in silent mode for the repo linked to the function? In silent mode, comments will not be made on commits and pull requests.
+     * @param {string} providerRootDirectory - Path to function code in the linked repo.
+     * @param {string} specification - Runtime specification for the function and builds.
      * @throws {AppwriteException}
      * @returns {Promise<Models.Function>}
+     * @deprecated Use the object parameter style method for a better developer experience.
      */
-    create(functionId: string, name: string, runtime: Runtime, execute?: string[], events?: string[], schedule?: string, timeout?: number, enabled?: boolean, logging?: boolean, entrypoint?: string, commands?: string, scopes?: string[], installationId?: string, providerRepositoryId?: string, providerBranch?: string, providerSilentMode?: boolean, providerRootDirectory?: string, specification?: string): Promise<Models.Function> {
+    create(functionId: string, name: string, runtime: Runtime, execute?: string[], events?: string[], schedule?: string, timeout?: number, enabled?: boolean, logging?: boolean, entrypoint?: string, commands?: string, scopes?: string[], installationId?: string, providerRepositoryId?: string, providerBranch?: string, providerSilentMode?: boolean, providerRootDirectory?: string, specification?: string): Promise<Models.Function>;
+    create(
+        paramsOrFirst: { functionId: string, name: string, runtime: Runtime, execute?: string[], events?: string[], schedule?: string, timeout?: number, enabled?: boolean, logging?: boolean, entrypoint?: string, commands?: string, scopes?: string[], installationId?: string, providerRepositoryId?: string, providerBranch?: string, providerSilentMode?: boolean, providerRootDirectory?: string, specification?: string } | string,
+        ...rest: [(string)?, (Runtime)?, (string[])?, (string[])?, (string)?, (number)?, (boolean)?, (boolean)?, (string)?, (string)?, (string[])?, (string)?, (string)?, (string)?, (boolean)?, (string)?, (string)?]    
+    ): Promise<Models.Function> {
+        let params: { functionId: string, name: string, runtime: Runtime, execute?: string[], events?: string[], schedule?: string, timeout?: number, enabled?: boolean, logging?: boolean, entrypoint?: string, commands?: string, scopes?: string[], installationId?: string, providerRepositoryId?: string, providerBranch?: string, providerSilentMode?: boolean, providerRootDirectory?: string, specification?: string };
+        
+        if ((paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst))) {
+            params = (paramsOrFirst || {}) as { functionId: string, name: string, runtime: Runtime, execute?: string[], events?: string[], schedule?: string, timeout?: number, enabled?: boolean, logging?: boolean, entrypoint?: string, commands?: string, scopes?: string[], installationId?: string, providerRepositoryId?: string, providerBranch?: string, providerSilentMode?: boolean, providerRootDirectory?: string, specification?: string };
+        } else {
+            params = {
+                functionId: paramsOrFirst as string,
+                name: rest[0] as string,
+                runtime: rest[1] as Runtime,
+                execute: rest[2] as string[],
+                events: rest[3] as string[],
+                schedule: rest[4] as string,
+                timeout: rest[5] as number,
+                enabled: rest[6] as boolean,
+                logging: rest[7] as boolean,
+                entrypoint: rest[8] as string,
+                commands: rest[9] as string,
+                scopes: rest[10] as string[],
+                installationId: rest[11] as string,
+                providerRepositoryId: rest[12] as string,
+                providerBranch: rest[13] as string,
+                providerSilentMode: rest[14] as boolean,
+                providerRootDirectory: rest[15] as string,
+                specification: rest[16] as string            
+            };
+        }
+        
+        const functionId = params.functionId;
+        const name = params.name;
+        const runtime = params.runtime;
+        const execute = params.execute;
+        const events = params.events;
+        const schedule = params.schedule;
+        const timeout = params.timeout;
+        const enabled = params.enabled;
+        const logging = params.logging;
+        const entrypoint = params.entrypoint;
+        const commands = params.commands;
+        const scopes = params.scopes;
+        const installationId = params.installationId;
+        const providerRepositoryId = params.providerRepositoryId;
+        const providerBranch = params.providerBranch;
+        const providerSilentMode = params.providerSilentMode;
+        const providerRootDirectory = params.providerRootDirectory;
+        const specification = params.specification;
+
         if (typeof functionId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "functionId"');
         }
@@ -78,6 +192,7 @@ export class Functions {
         if (typeof runtime === 'undefined') {
             throw new AppwriteException('Missing required parameter: "runtime"');
         }
+
         const apiPath = '/functions';
         const payload: Payload = {};
         if (typeof functionId !== 'undefined') {
@@ -155,6 +270,7 @@ export class Functions {
      * @returns {Promise<Models.RuntimeList>}
      */
     listRuntimes(): Promise<Models.RuntimeList> {
+
         const apiPath = '/functions/runtimes';
         const payload: Payload = {};
         const uri = new URL(this.client.config.endpoint + apiPath);
@@ -177,6 +293,7 @@ export class Functions {
      * @returns {Promise<Models.SpecificationList>}
      */
     listSpecifications(): Promise<Models.SpecificationList> {
+
         const apiPath = '/functions/specifications';
         const payload: Payload = {};
         const uri = new URL(this.client.config.endpoint + apiPath);
@@ -195,14 +312,53 @@ export class Functions {
     /**
      * List available function templates. You can use template details in [createFunction](/docs/references/cloud/server-nodejs/functions#create) method.
      *
-     * @param {string[]} runtimes
-     * @param {string[]} useCases
-     * @param {number} limit
-     * @param {number} offset
+     * @param {string[]} params.runtimes - List of runtimes allowed for filtering function templates. Maximum of 100 runtimes are allowed.
+     * @param {string[]} params.useCases - List of use cases allowed for filtering function templates. Maximum of 100 use cases are allowed.
+     * @param {number} params.limit - Limit the number of templates returned in the response. Default limit is 25, and maximum limit is 5000.
+     * @param {number} params.offset - Offset the list of returned templates. Maximum offset is 5000.
+     * @param {boolean} params.total - When set to false, the total count returned will be 0 and will not be calculated.
+     * @throws {AppwriteException}
+     * @returns {Promise<Models.TemplateFunctionList>}
+     */
+    listTemplates(params?: { runtimes?: string[], useCases?: string[], limit?: number, offset?: number, total?: boolean  }): Promise<Models.TemplateFunctionList>;
+    /**
+     * List available function templates. You can use template details in [createFunction](/docs/references/cloud/server-nodejs/functions#create) method.
+     *
+     * @param {string[]} runtimes - List of runtimes allowed for filtering function templates. Maximum of 100 runtimes are allowed.
+     * @param {string[]} useCases - List of use cases allowed for filtering function templates. Maximum of 100 use cases are allowed.
+     * @param {number} limit - Limit the number of templates returned in the response. Default limit is 25, and maximum limit is 5000.
+     * @param {number} offset - Offset the list of returned templates. Maximum offset is 5000.
+     * @param {boolean} total - When set to false, the total count returned will be 0 and will not be calculated.
      * @throws {AppwriteException}
      * @returns {Promise<Models.TemplateFunctionList>}
+     * @deprecated Use the object parameter style method for a better developer experience.
      */
-    listTemplates(runtimes?: string[], useCases?: string[], limit?: number, offset?: number): Promise<Models.TemplateFunctionList> {
+    listTemplates(runtimes?: string[], useCases?: string[], limit?: number, offset?: number, total?: boolean): Promise<Models.TemplateFunctionList>;
+    listTemplates(
+        paramsOrFirst?: { runtimes?: string[], useCases?: string[], limit?: number, offset?: number, total?: boolean } | string[],
+        ...rest: [(string[])?, (number)?, (number)?, (boolean)?]    
+    ): Promise<Models.TemplateFunctionList> {
+        let params: { runtimes?: string[], useCases?: string[], limit?: number, offset?: number, total?: boolean };
+        
+        if (!paramsOrFirst || (paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst))) {
+            params = (paramsOrFirst || {}) as { runtimes?: string[], useCases?: string[], limit?: number, offset?: number, total?: boolean };
+        } else {
+            params = {
+                runtimes: paramsOrFirst as string[],
+                useCases: rest[0] as string[],
+                limit: rest[1] as number,
+                offset: rest[2] as number,
+                total: rest[3] as boolean            
+            };
+        }
+        
+        const runtimes = params.runtimes;
+        const useCases = params.useCases;
+        const limit = params.limit;
+        const offset = params.offset;
+        const total = params.total;
+
+
         const apiPath = '/functions/templates';
         const payload: Payload = {};
         if (typeof runtimes !== 'undefined') {
@@ -217,6 +373,9 @@ export class Functions {
         if (typeof offset !== 'undefined') {
             payload['offset'] = offset;
         }
+        if (typeof total !== 'undefined') {
+            payload['total'] = total;
+        }
         const uri = new URL(this.client.config.endpoint + apiPath);
 
         const apiHeaders: { [header: string]: string } = {
@@ -233,14 +392,39 @@ export class Functions {
     /**
      * Get a function template using ID. You can use template details in [createFunction](/docs/references/cloud/server-nodejs/functions#create) method.
      *
-     * @param {string} templateId
+     * @param {string} params.templateId - Template ID.
+     * @throws {AppwriteException}
+     * @returns {Promise<Models.TemplateFunction>}
+     */
+    getTemplate(params: { templateId: string  }): Promise<Models.TemplateFunction>;
+    /**
+     * Get a function template using ID. You can use template details in [createFunction](/docs/references/cloud/server-nodejs/functions#create) method.
+     *
+     * @param {string} templateId - Template ID.
      * @throws {AppwriteException}
      * @returns {Promise<Models.TemplateFunction>}
+     * @deprecated Use the object parameter style method for a better developer experience.
      */
-    getTemplate(templateId: string): Promise<Models.TemplateFunction> {
+    getTemplate(templateId: string): Promise<Models.TemplateFunction>;
+    getTemplate(
+        paramsOrFirst: { templateId: string } | string    
+    ): Promise<Models.TemplateFunction> {
+        let params: { templateId: string };
+        
+        if ((paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst))) {
+            params = (paramsOrFirst || {}) as { templateId: string };
+        } else {
+            params = {
+                templateId: paramsOrFirst as string            
+            };
+        }
+        
+        const templateId = params.templateId;
+
         if (typeof templateId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "templateId"');
         }
+
         const apiPath = '/functions/templates/{templateId}'.replace('{templateId}', templateId);
         const payload: Payload = {};
         const uri = new URL(this.client.config.endpoint + apiPath);
@@ -259,11 +443,36 @@ export class Functions {
     /**
      * Get usage metrics and statistics for all functions in the project. View statistics including total deployments, builds, logs, storage usage, and compute time. The response includes both current totals and historical data for each metric. Use the optional range parameter to specify the time window for historical data: 24h (last 24 hours), 30d (last 30 days), or 90d (last 90 days). If not specified, defaults to 30 days.
      *
-     * @param {FunctionUsageRange} range
+     * @param {UsageRange} params.range - Date range.
      * @throws {AppwriteException}
      * @returns {Promise<Models.UsageFunctions>}
      */
-    listUsage(range?: FunctionUsageRange): Promise<Models.UsageFunctions> {
+    listUsage(params?: { range?: UsageRange  }): Promise<Models.UsageFunctions>;
+    /**
+     * Get usage metrics and statistics for all functions in the project. View statistics including total deployments, builds, logs, storage usage, and compute time. The response includes both current totals and historical data for each metric. Use the optional range parameter to specify the time window for historical data: 24h (last 24 hours), 30d (last 30 days), or 90d (last 90 days). If not specified, defaults to 30 days.
+     *
+     * @param {UsageRange} range - Date range.
+     * @throws {AppwriteException}
+     * @returns {Promise<Models.UsageFunctions>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    listUsage(range?: UsageRange): Promise<Models.UsageFunctions>;
+    listUsage(
+        paramsOrFirst?: { range?: UsageRange } | UsageRange    
+    ): Promise<Models.UsageFunctions> {
+        let params: { range?: UsageRange };
+        
+        if (!paramsOrFirst || (paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst) && 'range' in paramsOrFirst)) {
+            params = (paramsOrFirst || {}) as { range?: UsageRange };
+        } else {
+            params = {
+                range: paramsOrFirst as UsageRange            
+            };
+        }
+        
+        const range = params.range;
+
+
         const apiPath = '/functions/usage';
         const payload: Payload = {};
         if (typeof range !== 'undefined') {
@@ -285,14 +494,39 @@ export class Functions {
     /**
      * Get a function by its unique ID.
      *
-     * @param {string} functionId
+     * @param {string} params.functionId - Function ID.
      * @throws {AppwriteException}
      * @returns {Promise<Models.Function>}
      */
-    get(functionId: string): Promise<Models.Function> {
+    get(params: { functionId: string  }): Promise<Models.Function>;
+    /**
+     * Get a function by its unique ID.
+     *
+     * @param {string} functionId - Function ID.
+     * @throws {AppwriteException}
+     * @returns {Promise<Models.Function>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    get(functionId: string): Promise<Models.Function>;
+    get(
+        paramsOrFirst: { functionId: string } | string    
+    ): Promise<Models.Function> {
+        let params: { functionId: string };
+        
+        if ((paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst))) {
+            params = (paramsOrFirst || {}) as { functionId: string };
+        } else {
+            params = {
+                functionId: paramsOrFirst as string            
+            };
+        }
+        
+        const functionId = params.functionId;
+
         if (typeof functionId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "functionId"');
         }
+
         const apiPath = '/functions/{functionId}'.replace('{functionId}', functionId);
         const payload: Payload = {};
         const uri = new URL(this.client.config.endpoint + apiPath);
@@ -311,34 +545,111 @@ export class Functions {
     /**
      * Update function by its unique ID.
      *
-     * @param {string} functionId
-     * @param {string} name
-     * @param {Runtime} 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[]} scopes
-     * @param {string} installationId
-     * @param {string} providerRepositoryId
-     * @param {string} providerBranch
-     * @param {boolean} providerSilentMode
-     * @param {string} providerRootDirectory
-     * @param {string} specification
+     * @param {string} params.functionId - Function ID.
+     * @param {string} params.name - Function name. Max length: 128 chars.
+     * @param {Runtime} params.runtime - Execution runtime.
+     * @param {string[]} params.execute - An array of role strings with execution permissions. By default no user is granted with any execute permissions. [learn more about roles](https://appwrite.io/docs/permissions#permission-roles). Maximum of 100 roles are allowed, each 64 characters long.
+     * @param {string[]} params.events - Events list. Maximum of 100 events are allowed.
+     * @param {string} params.schedule - Schedule CRON syntax.
+     * @param {number} params.timeout - Maximum execution time in seconds.
+     * @param {boolean} params.enabled - Is function enabled? When set to 'disabled', users cannot access the function but Server SDKs with and API key can still access the function. No data is lost when this is toggled.
+     * @param {boolean} params.logging - When disabled, executions will exclude logs and errors, and will be slightly faster.
+     * @param {string} params.entrypoint - Entrypoint File. This path is relative to the "providerRootDirectory".
+     * @param {string} params.commands - Build Commands.
+     * @param {string[]} params.scopes - List of scopes allowed for API Key auto-generated for every execution. Maximum of 100 scopes are allowed.
+     * @param {string} params.installationId - Appwrite Installation ID for VCS (Version Controle System) deployment.
+     * @param {string} params.providerRepositoryId - Repository ID of the repo linked to the function
+     * @param {string} params.providerBranch - Production branch for the repo linked to the function
+     * @param {boolean} params.providerSilentMode - Is the VCS (Version Control System) connection in silent mode for the repo linked to the function? In silent mode, comments will not be made on commits and pull requests.
+     * @param {string} params.providerRootDirectory - Path to function code in the linked repo.
+     * @param {string} params.specification - Runtime specification for the function and builds.
+     * @throws {AppwriteException}
+     * @returns {Promise<Models.Function>}
+     */
+    update(params: { functionId: string, name: string, runtime?: Runtime, execute?: string[], events?: string[], schedule?: string, timeout?: number, enabled?: boolean, logging?: boolean, entrypoint?: string, commands?: string, scopes?: string[], installationId?: string, providerRepositoryId?: string, providerBranch?: string, providerSilentMode?: boolean, providerRootDirectory?: string, specification?: string  }): Promise<Models.Function>;
+    /**
+     * Update function by its unique ID.
+     *
+     * @param {string} functionId - Function ID.
+     * @param {string} name - Function name. Max length: 128 chars.
+     * @param {Runtime} runtime - Execution runtime.
+     * @param {string[]} execute - An array of role strings with execution permissions. By default no user is granted with any execute permissions. [learn more about roles](https://appwrite.io/docs/permissions#permission-roles). Maximum of 100 roles are allowed, each 64 characters long.
+     * @param {string[]} events - Events list. Maximum of 100 events are allowed.
+     * @param {string} schedule - Schedule CRON syntax.
+     * @param {number} timeout - Maximum execution time in seconds.
+     * @param {boolean} enabled - Is function enabled? When set to 'disabled', users cannot access the function but Server SDKs with and API key can still access the function. No data is lost when this is toggled.
+     * @param {boolean} logging - When disabled, executions will exclude logs and errors, and will be slightly faster.
+     * @param {string} entrypoint - Entrypoint File. This path is relative to the "providerRootDirectory".
+     * @param {string} commands - Build Commands.
+     * @param {string[]} scopes - List of scopes allowed for API Key auto-generated for every execution. Maximum of 100 scopes are allowed.
+     * @param {string} installationId - Appwrite Installation ID for VCS (Version Controle System) deployment.
+     * @param {string} providerRepositoryId - Repository ID of the repo linked to the function
+     * @param {string} providerBranch - Production branch for the repo linked to the function
+     * @param {boolean} providerSilentMode - Is the VCS (Version Control System) connection in silent mode for the repo linked to the function? In silent mode, comments will not be made on commits and pull requests.
+     * @param {string} providerRootDirectory - Path to function code in the linked repo.
+     * @param {string} specification - Runtime specification for the function and builds.
      * @throws {AppwriteException}
      * @returns {Promise<Models.Function>}
+     * @deprecated Use the object parameter style method for a better developer experience.
      */
-    update(functionId: string, name: string, runtime?: Runtime, execute?: string[], events?: string[], schedule?: string, timeout?: number, enabled?: boolean, logging?: boolean, entrypoint?: string, commands?: string, scopes?: string[], installationId?: string, providerRepositoryId?: string, providerBranch?: string, providerSilentMode?: boolean, providerRootDirectory?: string, specification?: string): Promise<Models.Function> {
+    update(functionId: string, name: string, runtime?: Runtime, execute?: string[], events?: string[], schedule?: string, timeout?: number, enabled?: boolean, logging?: boolean, entrypoint?: string, commands?: string, scopes?: string[], installationId?: string, providerRepositoryId?: string, providerBranch?: string, providerSilentMode?: boolean, providerRootDirectory?: string, specification?: string): Promise<Models.Function>;
+    update(
+        paramsOrFirst: { functionId: string, name: string, runtime?: Runtime, execute?: string[], events?: string[], schedule?: string, timeout?: number, enabled?: boolean, logging?: boolean, entrypoint?: string, commands?: string, scopes?: string[], installationId?: string, providerRepositoryId?: string, providerBranch?: string, providerSilentMode?: boolean, providerRootDirectory?: string, specification?: string } | string,
+        ...rest: [(string)?, (Runtime)?, (string[])?, (string[])?, (string)?, (number)?, (boolean)?, (boolean)?, (string)?, (string)?, (string[])?, (string)?, (string)?, (string)?, (boolean)?, (string)?, (string)?]    
+    ): Promise<Models.Function> {
+        let params: { functionId: string, name: string, runtime?: Runtime, execute?: string[], events?: string[], schedule?: string, timeout?: number, enabled?: boolean, logging?: boolean, entrypoint?: string, commands?: string, scopes?: string[], installationId?: string, providerRepositoryId?: string, providerBranch?: string, providerSilentMode?: boolean, providerRootDirectory?: string, specification?: string };
+        
+        if ((paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst))) {
+            params = (paramsOrFirst || {}) as { functionId: string, name: string, runtime?: Runtime, execute?: string[], events?: string[], schedule?: string, timeout?: number, enabled?: boolean, logging?: boolean, entrypoint?: string, commands?: string, scopes?: string[], installationId?: string, providerRepositoryId?: string, providerBranch?: string, providerSilentMode?: boolean, providerRootDirectory?: string, specification?: string };
+        } else {
+            params = {
+                functionId: paramsOrFirst as string,
+                name: rest[0] as string,
+                runtime: rest[1] as Runtime,
+                execute: rest[2] as string[],
+                events: rest[3] as string[],
+                schedule: rest[4] as string,
+                timeout: rest[5] as number,
+                enabled: rest[6] as boolean,
+                logging: rest[7] as boolean,
+                entrypoint: rest[8] as string,
+                commands: rest[9] as string,
+                scopes: rest[10] as string[],
+                installationId: rest[11] as string,
+                providerRepositoryId: rest[12] as string,
+                providerBranch: rest[13] as string,
+                providerSilentMode: rest[14] as boolean,
+                providerRootDirectory: rest[15] as string,
+                specification: rest[16] as string            
+            };
+        }
+        
+        const functionId = params.functionId;
+        const name = params.name;
+        const runtime = params.runtime;
+        const execute = params.execute;
+        const events = params.events;
+        const schedule = params.schedule;
+        const timeout = params.timeout;
+        const enabled = params.enabled;
+        const logging = params.logging;
+        const entrypoint = params.entrypoint;
+        const commands = params.commands;
+        const scopes = params.scopes;
+        const installationId = params.installationId;
+        const providerRepositoryId = params.providerRepositoryId;
+        const providerBranch = params.providerBranch;
+        const providerSilentMode = params.providerSilentMode;
+        const providerRootDirectory = params.providerRootDirectory;
+        const specification = params.specification;
+
         if (typeof functionId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "functionId"');
         }
         if (typeof name === 'undefined') {
             throw new AppwriteException('Missing required parameter: "name"');
         }
+
         const apiPath = '/functions/{functionId}'.replace('{functionId}', functionId);
         const payload: Payload = {};
         if (typeof name !== 'undefined') {
@@ -409,14 +720,39 @@ export class Functions {
     /**
      * Delete a function by its unique ID.
      *
-     * @param {string} functionId
+     * @param {string} params.functionId - Function ID.
      * @throws {AppwriteException}
      * @returns {Promise<{}>}
      */
-    delete(functionId: string): Promise<{}> {
+    delete(params: { functionId: string  }): Promise<{}>;
+    /**
+     * Delete a function by its unique ID.
+     *
+     * @param {string} functionId - Function ID.
+     * @throws {AppwriteException}
+     * @returns {Promise<{}>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    delete(functionId: string): Promise<{}>;
+    delete(
+        paramsOrFirst: { functionId: string } | string    
+    ): Promise<{}> {
+        let params: { functionId: string };
+        
+        if ((paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst))) {
+            params = (paramsOrFirst || {}) as { functionId: string };
+        } else {
+            params = {
+                functionId: paramsOrFirst as string            
+            };
+        }
+        
+        const functionId = params.functionId;
+
         if (typeof functionId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "functionId"');
         }
+
         const apiPath = '/functions/{functionId}'.replace('{functionId}', functionId);
         const payload: Payload = {};
         const uri = new URL(this.client.config.endpoint + apiPath);
@@ -436,18 +772,47 @@ export class Functions {
     /**
      * Update the function active deployment. Use this endpoint to switch the code deployment that should be used when visitor opens your function.
      *
-     * @param {string} functionId
-     * @param {string} deploymentId
+     * @param {string} params.functionId - Function ID.
+     * @param {string} params.deploymentId - Deployment ID.
      * @throws {AppwriteException}
      * @returns {Promise<Models.Function>}
      */
-    updateFunctionDeployment(functionId: string, deploymentId: string): Promise<Models.Function> {
+    updateFunctionDeployment(params: { functionId: string, deploymentId: string  }): Promise<Models.Function>;
+    /**
+     * Update the function active deployment. Use this endpoint to switch the code deployment that should be used when visitor opens your function.
+     *
+     * @param {string} functionId - Function ID.
+     * @param {string} deploymentId - Deployment ID.
+     * @throws {AppwriteException}
+     * @returns {Promise<Models.Function>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    updateFunctionDeployment(functionId: string, deploymentId: string): Promise<Models.Function>;
+    updateFunctionDeployment(
+        paramsOrFirst: { functionId: string, deploymentId: string } | string,
+        ...rest: [(string)?]    
+    ): Promise<Models.Function> {
+        let params: { functionId: string, deploymentId: string };
+        
+        if ((paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst))) {
+            params = (paramsOrFirst || {}) as { functionId: string, deploymentId: string };
+        } else {
+            params = {
+                functionId: paramsOrFirst as string,
+                deploymentId: rest[0] as string            
+            };
+        }
+        
+        const functionId = params.functionId;
+        const deploymentId = params.deploymentId;
+
         if (typeof functionId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "functionId"');
         }
         if (typeof deploymentId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "deploymentId"');
         }
+
         const apiPath = '/functions/{functionId}/deployment'.replace('{functionId}', functionId);
         const payload: Payload = {};
         if (typeof deploymentId !== 'undefined') {
@@ -468,18 +833,54 @@ export class Functions {
     }
 
     /**
-     * Get a list of all the function&#039;s code deployments. You can use the query params to filter your results.
+     * Get a list of all the function's code deployments. You can use the query params to filter your results.
      *
-     * @param {string} functionId
-     * @param {string[]} queries
-     * @param {string} search
+     * @param {string} params.functionId - Function ID.
+     * @param {string[]} params.queries - Array of query strings generated using the Query class provided by the SDK. [Learn more about queries](https://appwrite.io/docs/queries). Maximum of 100 queries are allowed, each 4096 characters long. You may filter on the following attributes: buildSize, sourceSize, totalSize, buildDuration, status, activate, type
+     * @param {string} params.search - Search term to filter your list results. Max length: 256 chars.
+     * @param {boolean} params.total - When set to false, the total count returned will be 0 and will not be calculated.
      * @throws {AppwriteException}
      * @returns {Promise<Models.DeploymentList>}
      */
-    listDeployments(functionId: string, queries?: string[], search?: string): Promise<Models.DeploymentList> {
+    listDeployments(params: { functionId: string, queries?: string[], search?: string, total?: boolean  }): Promise<Models.DeploymentList>;
+    /**
+     * Get a list of all the function's code deployments. You can use the query params to filter your results.
+     *
+     * @param {string} functionId - Function ID.
+     * @param {string[]} queries - Array of query strings generated using the Query class provided by the SDK. [Learn more about queries](https://appwrite.io/docs/queries). Maximum of 100 queries are allowed, each 4096 characters long. You may filter on the following attributes: buildSize, sourceSize, totalSize, buildDuration, status, activate, type
+     * @param {string} search - Search term to filter your list results. Max length: 256 chars.
+     * @param {boolean} total - When set to false, the total count returned will be 0 and will not be calculated.
+     * @throws {AppwriteException}
+     * @returns {Promise<Models.DeploymentList>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    listDeployments(functionId: string, queries?: string[], search?: string, total?: boolean): Promise<Models.DeploymentList>;
+    listDeployments(
+        paramsOrFirst: { functionId: string, queries?: string[], search?: string, total?: boolean } | string,
+        ...rest: [(string[])?, (string)?, (boolean)?]    
+    ): Promise<Models.DeploymentList> {
+        let params: { functionId: string, queries?: string[], search?: string, total?: boolean };
+        
+        if ((paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst))) {
+            params = (paramsOrFirst || {}) as { functionId: string, queries?: string[], search?: string, total?: boolean };
+        } else {
+            params = {
+                functionId: paramsOrFirst as string,
+                queries: rest[0] as string[],
+                search: rest[1] as string,
+                total: rest[2] as boolean            
+            };
+        }
+        
+        const functionId = params.functionId;
+        const queries = params.queries;
+        const search = params.search;
+        const total = params.total;
+
         if (typeof functionId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "functionId"');
         }
+
         const apiPath = '/functions/{functionId}/deployments'.replace('{functionId}', functionId);
         const payload: Payload = {};
         if (typeof queries !== 'undefined') {
@@ -488,6 +889,9 @@ export class Functions {
         if (typeof search !== 'undefined') {
             payload['search'] = search;
         }
+        if (typeof total !== 'undefined') {
+            payload['total'] = total;
+        }
         const uri = new URL(this.client.config.endpoint + apiPath);
 
         const apiHeaders: { [header: string]: string } = {
@@ -502,21 +906,65 @@ export class Functions {
     }
 
     /**
-     * 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&#039;ll need to update the function&#039;s deployment to use your new deployment UID.
+     * 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](https://appwrite.io/docs/functions).
+     * 
+     * Use the "command" param to set the entrypoint used to execute your code.
+     *
+     * @param {string} params.functionId - Function ID.
+     * @param {File} params.code - Gzip file with your code package. When used with the Appwrite CLI, pass the path to your code directory, and the CLI will automatically package your code. Use a path that is within the current directory.
+     * @param {boolean} params.activate - Automatically activate the deployment when it is finished building.
+     * @param {string} params.entrypoint - Entrypoint File.
+     * @param {string} params.commands - Build Commands.
+     * @throws {AppwriteException}
+     * @returns {Promise<Models.Deployment>}
+     */
+    createDeployment(params: { functionId: string, code: File, activate: boolean, entrypoint?: string, commands?: string , onProgress?: (progress: UploadProgress) => void }): Promise<Models.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](https://appwrite.io/docs/functions).
      * 
-     * Use the &quot;command&quot; param to set the entrypoint used to execute your code.
+     * 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
+     * @param {string} functionId - Function ID.
+     * @param {File} code - Gzip file with your code package. When used with the Appwrite CLI, pass the path to your code directory, and the CLI will automatically package your code. Use a path that is within the current directory.
+     * @param {boolean} activate - Automatically activate the deployment when it is finished building.
+     * @param {string} entrypoint - Entrypoint File.
+     * @param {string} commands - Build Commands.
      * @throws {AppwriteException}
      * @returns {Promise<Models.Deployment>}
+     * @deprecated Use the object parameter style method for a better developer experience.
      */
-    createDeployment(functionId: string, code: File, activate: boolean, entrypoint?: string, commands?: string, onProgress = (progress: UploadProgress) => {}): Promise<Models.Deployment> {
+    createDeployment(functionId: string, code: File, activate: boolean, entrypoint?: string, commands?: string, onProgress?: (progress: UploadProgress) => void): Promise<Models.Deployment>;
+    createDeployment(
+        paramsOrFirst: { functionId: string, code: File, activate: boolean, entrypoint?: string, commands?: string, onProgress?: (progress: UploadProgress) => void  } | string,
+        ...rest: [(File)?, (boolean)?, (string)?, (string)?,((progress: UploadProgress) => void)?]    
+    ): Promise<Models.Deployment> {
+        let params: { functionId: string, code: File, activate: boolean, entrypoint?: string, commands?: string };
+        let onProgress: ((progress: UploadProgress) => void);
+        
+        if ((paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst))) {
+            params = (paramsOrFirst || {}) as { functionId: string, code: File, activate: boolean, entrypoint?: string, commands?: string };
+            onProgress = paramsOrFirst?.onProgress as ((progress: UploadProgress) => void);
+        } else {
+            params = {
+                functionId: paramsOrFirst as string,
+                code: rest[0] as File,
+                activate: rest[1] as boolean,
+                entrypoint: rest[2] as string,
+                commands: rest[3] as string            
+            };
+            onProgress = rest[4] as ((progress: UploadProgress) => void);
+        }
+        
+        const functionId = params.functionId;
+        const code = params.code;
+        const activate = params.activate;
+        const entrypoint = params.entrypoint;
+        const commands = params.commands;
+
         if (typeof functionId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "functionId"');
         }
@@ -526,6 +974,7 @@ export class Functions {
         if (typeof activate === 'undefined') {
             throw new AppwriteException('Missing required parameter: "activate"');
         }
+
         const apiPath = '/functions/{functionId}/deployments'.replace('{functionId}', functionId);
         const payload: Payload = {};
         if (typeof entrypoint !== 'undefined') {
@@ -556,21 +1005,53 @@ export class Functions {
     }
 
     /**
-     * Create a new build for an existing function deployment. This endpoint allows you to rebuild a deployment with the updated function configuration, including its entrypoint and build commands if they have been modified. The build process will be queued and executed asynchronously. The original deployment&#039;s code will be preserved and used for the new build.
+     * Create a new build for an existing function deployment. This endpoint allows you to rebuild a deployment with the updated function configuration, including its entrypoint and build commands if they have been modified. The build process will be queued and executed asynchronously. The original deployment's code will be preserved and used for the new build.
+     *
+     * @param {string} params.functionId - Function ID.
+     * @param {string} params.deploymentId - Deployment ID.
+     * @param {string} params.buildId - Build unique ID.
+     * @throws {AppwriteException}
+     * @returns {Promise<Models.Deployment>}
+     */
+    createDuplicateDeployment(params: { functionId: string, deploymentId: string, buildId?: string  }): Promise<Models.Deployment>;
+    /**
+     * Create a new build for an existing function deployment. This endpoint allows you to rebuild a deployment with the updated function configuration, including its entrypoint and build commands if they have been modified. The build process will be queued and executed asynchronously. The original deployment's code will be preserved and used for the new build.
      *
-     * @param {string} functionId
-     * @param {string} deploymentId
-     * @param {string} buildId
+     * @param {string} functionId - Function ID.
+     * @param {string} deploymentId - Deployment ID.
+     * @param {string} buildId - Build unique ID.
      * @throws {AppwriteException}
      * @returns {Promise<Models.Deployment>}
+     * @deprecated Use the object parameter style method for a better developer experience.
      */
-    createDuplicateDeployment(functionId: string, deploymentId: string, buildId?: string): Promise<Models.Deployment> {
+    createDuplicateDeployment(functionId: string, deploymentId: string, buildId?: string): Promise<Models.Deployment>;
+    createDuplicateDeployment(
+        paramsOrFirst: { functionId: string, deploymentId: string, buildId?: string } | string,
+        ...rest: [(string)?, (string)?]    
+    ): Promise<Models.Deployment> {
+        let params: { functionId: string, deploymentId: string, buildId?: string };
+        
+        if ((paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst))) {
+            params = (paramsOrFirst || {}) as { functionId: string, deploymentId: string, buildId?: string };
+        } else {
+            params = {
+                functionId: paramsOrFirst as string,
+                deploymentId: rest[0] as string,
+                buildId: rest[1] as string            
+            };
+        }
+        
+        const functionId = params.functionId;
+        const deploymentId = params.deploymentId;
+        const buildId = params.buildId;
+
         if (typeof functionId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "functionId"');
         }
         if (typeof deploymentId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "deploymentId"');
         }
+
         const apiPath = '/functions/{functionId}/deployments/duplicate'.replace('{functionId}', functionId);
         const payload: Payload = {};
         if (typeof deploymentId !== 'undefined') {
@@ -596,18 +1077,64 @@ export class Functions {
     /**
      * Create a deployment based on a template.
      * 
-     * Use this endpoint with combination of [listTemplates](https://appwrite.io/docs/server/functions#listTemplates) to find the template details.
+     * Use this endpoint with combination of [listTemplates](https://appwrite.io/docs/products/functions/templates) to find the template details.
+     *
+     * @param {string} params.functionId - Function ID.
+     * @param {string} params.repository - Repository name of the template.
+     * @param {string} params.owner - The name of the owner of the template.
+     * @param {string} params.rootDirectory - Path to function code in the template repo.
+     * @param {TemplateReferenceType} params.type - Type for the reference provided. Can be commit, branch, or tag
+     * @param {string} params.reference - Reference value, can be a commit hash, branch name, or release tag
+     * @param {boolean} params.activate - Automatically activate the deployment when it is finished building.
+     * @throws {AppwriteException}
+     * @returns {Promise<Models.Deployment>}
+     */
+    createTemplateDeployment(params: { functionId: string, repository: string, owner: string, rootDirectory: string, type: TemplateReferenceType, reference: string, activate?: boolean  }): Promise<Models.Deployment>;
+    /**
+     * Create a deployment based on a template.
+     * 
+     * Use this endpoint with combination of [listTemplates](https://appwrite.io/docs/products/functions/templates) to find the template details.
      *
-     * @param {string} functionId
-     * @param {string} repository
-     * @param {string} owner
-     * @param {string} rootDirectory
-     * @param {string} version
-     * @param {boolean} activate
+     * @param {string} functionId - Function ID.
+     * @param {string} repository - Repository name of the template.
+     * @param {string} owner - The name of the owner of the template.
+     * @param {string} rootDirectory - Path to function code in the template repo.
+     * @param {TemplateReferenceType} type - Type for the reference provided. Can be commit, branch, or tag
+     * @param {string} reference - Reference value, can be a commit hash, branch name, or release tag
+     * @param {boolean} activate - Automatically activate the deployment when it is finished building.
      * @throws {AppwriteException}
      * @returns {Promise<Models.Deployment>}
+     * @deprecated Use the object parameter style method for a better developer experience.
      */
-    createTemplateDeployment(functionId: string, repository: string, owner: string, rootDirectory: string, version: string, activate?: boolean): Promise<Models.Deployment> {
+    createTemplateDeployment(functionId: string, repository: string, owner: string, rootDirectory: string, type: TemplateReferenceType, reference: string, activate?: boolean): Promise<Models.Deployment>;
+    createTemplateDeployment(
+        paramsOrFirst: { functionId: string, repository: string, owner: string, rootDirectory: string, type: TemplateReferenceType, reference: string, activate?: boolean } | string,
+        ...rest: [(string)?, (string)?, (string)?, (TemplateReferenceType)?, (string)?, (boolean)?]    
+    ): Promise<Models.Deployment> {
+        let params: { functionId: string, repository: string, owner: string, rootDirectory: string, type: TemplateReferenceType, reference: string, activate?: boolean };
+        
+        if ((paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst))) {
+            params = (paramsOrFirst || {}) as { functionId: string, repository: string, owner: string, rootDirectory: string, type: TemplateReferenceType, reference: string, activate?: boolean };
+        } else {
+            params = {
+                functionId: paramsOrFirst as string,
+                repository: rest[0] as string,
+                owner: rest[1] as string,
+                rootDirectory: rest[2] as string,
+                type: rest[3] as TemplateReferenceType,
+                reference: rest[4] as string,
+                activate: rest[5] as boolean            
+            };
+        }
+        
+        const functionId = params.functionId;
+        const repository = params.repository;
+        const owner = params.owner;
+        const rootDirectory = params.rootDirectory;
+        const type = params.type;
+        const reference = params.reference;
+        const activate = params.activate;
+
         if (typeof functionId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "functionId"');
         }
@@ -620,9 +1147,13 @@ export class Functions {
         if (typeof rootDirectory === 'undefined') {
             throw new AppwriteException('Missing required parameter: "rootDirectory"');
         }
-        if (typeof version === 'undefined') {
-            throw new AppwriteException('Missing required parameter: "version"');
+        if (typeof type === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "type"');
+        }
+        if (typeof reference === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "reference"');
         }
+
         const apiPath = '/functions/{functionId}/deployments/template'.replace('{functionId}', functionId);
         const payload: Payload = {};
         if (typeof repository !== 'undefined') {
@@ -634,8 +1165,11 @@ export class Functions {
         if (typeof rootDirectory !== 'undefined') {
             payload['rootDirectory'] = rootDirectory;
         }
-        if (typeof version !== 'undefined') {
-            payload['version'] = version;
+        if (typeof type !== 'undefined') {
+            payload['type'] = type;
+        }
+        if (typeof reference !== 'undefined') {
+            payload['reference'] = reference;
         }
         if (typeof activate !== 'undefined') {
             payload['activate'] = activate;
@@ -659,14 +1193,50 @@ export class Functions {
      * 
      * This endpoint lets you create deployment from a branch, commit, or a tag.
      *
-     * @param {string} functionId
-     * @param {VCSDeploymentType} type
-     * @param {string} reference
-     * @param {boolean} activate
+     * @param {string} params.functionId - Function ID.
+     * @param {VCSReferenceType} params.type - Type of reference passed. Allowed values are: branch, commit
+     * @param {string} params.reference - VCS reference to create deployment from. Depending on type this can be: branch name, commit hash
+     * @param {boolean} params.activate - Automatically activate the deployment when it is finished building.
      * @throws {AppwriteException}
      * @returns {Promise<Models.Deployment>}
      */
-    createVcsDeployment(functionId: string, type: VCSDeploymentType, reference: string, activate?: boolean): Promise<Models.Deployment> {
+    createVcsDeployment(params: { functionId: string, type: VCSReferenceType, reference: string, activate?: boolean  }): Promise<Models.Deployment>;
+    /**
+     * Create a deployment when a function is connected to VCS.
+     * 
+     * This endpoint lets you create deployment from a branch, commit, or a tag.
+     *
+     * @param {string} functionId - Function ID.
+     * @param {VCSReferenceType} type - Type of reference passed. Allowed values are: branch, commit
+     * @param {string} reference - VCS reference to create deployment from. Depending on type this can be: branch name, commit hash
+     * @param {boolean} activate - Automatically activate the deployment when it is finished building.
+     * @throws {AppwriteException}
+     * @returns {Promise<Models.Deployment>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    createVcsDeployment(functionId: string, type: VCSReferenceType, reference: string, activate?: boolean): Promise<Models.Deployment>;
+    createVcsDeployment(
+        paramsOrFirst: { functionId: string, type: VCSReferenceType, reference: string, activate?: boolean } | string,
+        ...rest: [(VCSReferenceType)?, (string)?, (boolean)?]    
+    ): Promise<Models.Deployment> {
+        let params: { functionId: string, type: VCSReferenceType, reference: string, activate?: boolean };
+        
+        if ((paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst))) {
+            params = (paramsOrFirst || {}) as { functionId: string, type: VCSReferenceType, reference: string, activate?: boolean };
+        } else {
+            params = {
+                functionId: paramsOrFirst as string,
+                type: rest[0] as VCSReferenceType,
+                reference: rest[1] as string,
+                activate: rest[2] as boolean            
+            };
+        }
+        
+        const functionId = params.functionId;
+        const type = params.type;
+        const reference = params.reference;
+        const activate = params.activate;
+
         if (typeof functionId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "functionId"');
         }
@@ -676,6 +1246,7 @@ export class Functions {
         if (typeof reference === 'undefined') {
             throw new AppwriteException('Missing required parameter: "reference"');
         }
+
         const apiPath = '/functions/{functionId}/deployments/vcs'.replace('{functionId}', functionId);
         const payload: Payload = {};
         if (typeof type !== 'undefined') {
@@ -704,18 +1275,47 @@ export class Functions {
     /**
      * Get a function deployment by its unique ID.
      *
-     * @param {string} functionId
-     * @param {string} deploymentId
+     * @param {string} params.functionId - Function ID.
+     * @param {string} params.deploymentId - Deployment ID.
      * @throws {AppwriteException}
      * @returns {Promise<Models.Deployment>}
      */
-    getDeployment(functionId: string, deploymentId: string): Promise<Models.Deployment> {
+    getDeployment(params: { functionId: string, deploymentId: string  }): Promise<Models.Deployment>;
+    /**
+     * Get a function deployment by its unique ID.
+     *
+     * @param {string} functionId - Function ID.
+     * @param {string} deploymentId - Deployment ID.
+     * @throws {AppwriteException}
+     * @returns {Promise<Models.Deployment>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    getDeployment(functionId: string, deploymentId: string): Promise<Models.Deployment>;
+    getDeployment(
+        paramsOrFirst: { functionId: string, deploymentId: string } | string,
+        ...rest: [(string)?]    
+    ): Promise<Models.Deployment> {
+        let params: { functionId: string, deploymentId: string };
+        
+        if ((paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst))) {
+            params = (paramsOrFirst || {}) as { functionId: string, deploymentId: string };
+        } else {
+            params = {
+                functionId: paramsOrFirst as string,
+                deploymentId: rest[0] as string            
+            };
+        }
+        
+        const functionId = params.functionId;
+        const deploymentId = params.deploymentId;
+
         if (typeof functionId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "functionId"');
         }
         if (typeof deploymentId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "deploymentId"');
         }
+
         const apiPath = '/functions/{functionId}/deployments/{deploymentId}'.replace('{functionId}', functionId).replace('{deploymentId}', deploymentId);
         const payload: Payload = {};
         const uri = new URL(this.client.config.endpoint + apiPath);
@@ -734,18 +1334,47 @@ export class Functions {
     /**
      * Delete a code deployment by its unique ID.
      *
-     * @param {string} functionId
-     * @param {string} deploymentId
+     * @param {string} params.functionId - Function ID.
+     * @param {string} params.deploymentId - Deployment ID.
      * @throws {AppwriteException}
      * @returns {Promise<{}>}
      */
-    deleteDeployment(functionId: string, deploymentId: string): Promise<{}> {
+    deleteDeployment(params: { functionId: string, deploymentId: string  }): Promise<{}>;
+    /**
+     * Delete a code deployment by its unique ID.
+     *
+     * @param {string} functionId - Function ID.
+     * @param {string} deploymentId - Deployment ID.
+     * @throws {AppwriteException}
+     * @returns {Promise<{}>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    deleteDeployment(functionId: string, deploymentId: string): Promise<{}>;
+    deleteDeployment(
+        paramsOrFirst: { functionId: string, deploymentId: string } | string,
+        ...rest: [(string)?]    
+    ): Promise<{}> {
+        let params: { functionId: string, deploymentId: string };
+        
+        if ((paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst))) {
+            params = (paramsOrFirst || {}) as { functionId: string, deploymentId: string };
+        } else {
+            params = {
+                functionId: paramsOrFirst as string,
+                deploymentId: rest[0] as string            
+            };
+        }
+        
+        const functionId = params.functionId;
+        const deploymentId = params.deploymentId;
+
         if (typeof functionId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "functionId"');
         }
         if (typeof deploymentId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "deploymentId"');
         }
+
         const apiPath = '/functions/{functionId}/deployments/{deploymentId}'.replace('{functionId}', functionId).replace('{deploymentId}', deploymentId);
         const payload: Payload = {};
         const uri = new URL(this.client.config.endpoint + apiPath);
@@ -763,21 +1392,53 @@ export class Functions {
     }
 
     /**
-     * Get a function deployment content by its unique ID. The endpoint response return with a &#039;Content-Disposition: attachment&#039; header that tells the browser to start downloading the file to user downloads directory.
+     * Get a function deployment content by its unique ID. The endpoint response return with a 'Content-Disposition: attachment' header that tells the browser to start downloading the file to user downloads directory.
      *
-     * @param {string} functionId
-     * @param {string} deploymentId
-     * @param {DeploymentDownloadType} type
+     * @param {string} params.functionId - Function ID.
+     * @param {string} params.deploymentId - Deployment ID.
+     * @param {DeploymentDownloadType} params.type - Deployment file to download. Can be: "source", "output".
      * @throws {AppwriteException}
      * @returns {string}
      */
-    getDeploymentDownload(functionId: string, deploymentId: string, type?: DeploymentDownloadType): string {
+    getDeploymentDownload(params: { functionId: string, deploymentId: string, type?: DeploymentDownloadType  }): string;
+    /**
+     * Get a function deployment content by its unique ID. The endpoint response return with a 'Content-Disposition: attachment' header that tells the browser to start downloading the file to user downloads directory.
+     *
+     * @param {string} functionId - Function ID.
+     * @param {string} deploymentId - Deployment ID.
+     * @param {DeploymentDownloadType} type - Deployment file to download. Can be: "source", "output".
+     * @throws {AppwriteException}
+     * @returns {string}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    getDeploymentDownload(functionId: string, deploymentId: string, type?: DeploymentDownloadType): string;
+    getDeploymentDownload(
+        paramsOrFirst: { functionId: string, deploymentId: string, type?: DeploymentDownloadType } | string,
+        ...rest: [(string)?, (DeploymentDownloadType)?]    
+    ): string {
+        let params: { functionId: string, deploymentId: string, type?: DeploymentDownloadType };
+        
+        if ((paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst))) {
+            params = (paramsOrFirst || {}) as { functionId: string, deploymentId: string, type?: DeploymentDownloadType };
+        } else {
+            params = {
+                functionId: paramsOrFirst as string,
+                deploymentId: rest[0] as string,
+                type: rest[1] as DeploymentDownloadType            
+            };
+        }
+        
+        const functionId = params.functionId;
+        const deploymentId = params.deploymentId;
+        const type = params.type;
+
         if (typeof functionId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "functionId"');
         }
         if (typeof deploymentId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "deploymentId"');
         }
+
         const apiPath = '/functions/{functionId}/deployments/{deploymentId}/download'.replace('{functionId}', functionId).replace('{deploymentId}', deploymentId);
         const payload: Payload = {};
         if (typeof type !== 'undefined') {
@@ -798,20 +1459,49 @@ export class Functions {
     }
 
     /**
-     * Cancel an ongoing function deployment build. If the build is already in progress, it will be stopped and marked as canceled. If the build hasn&#039;t started yet, it will be marked as canceled without executing. You cannot cancel builds that have already completed (status &#039;ready&#039;) or failed. The response includes the final build status and details.
+     * Cancel an ongoing function deployment build. If the build is already in progress, it will be stopped and marked as canceled. If the build hasn't started yet, it will be marked as canceled without executing. You cannot cancel builds that have already completed (status 'ready') or failed. The response includes the final build status and details.
      *
-     * @param {string} functionId
-     * @param {string} deploymentId
+     * @param {string} params.functionId - Function ID.
+     * @param {string} params.deploymentId - Deployment ID.
      * @throws {AppwriteException}
      * @returns {Promise<Models.Deployment>}
      */
-    updateDeploymentStatus(functionId: string, deploymentId: string): Promise<Models.Deployment> {
+    updateDeploymentStatus(params: { functionId: string, deploymentId: string  }): Promise<Models.Deployment>;
+    /**
+     * Cancel an ongoing function deployment build. If the build is already in progress, it will be stopped and marked as canceled. If the build hasn't started yet, it will be marked as canceled without executing. You cannot cancel builds that have already completed (status 'ready') or failed. The response includes the final build status and details.
+     *
+     * @param {string} functionId - Function ID.
+     * @param {string} deploymentId - Deployment ID.
+     * @throws {AppwriteException}
+     * @returns {Promise<Models.Deployment>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    updateDeploymentStatus(functionId: string, deploymentId: string): Promise<Models.Deployment>;
+    updateDeploymentStatus(
+        paramsOrFirst: { functionId: string, deploymentId: string } | string,
+        ...rest: [(string)?]    
+    ): Promise<Models.Deployment> {
+        let params: { functionId: string, deploymentId: string };
+        
+        if ((paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst))) {
+            params = (paramsOrFirst || {}) as { functionId: string, deploymentId: string };
+        } else {
+            params = {
+                functionId: paramsOrFirst as string,
+                deploymentId: rest[0] as string            
+            };
+        }
+        
+        const functionId = params.functionId;
+        const deploymentId = params.deploymentId;
+
         if (typeof functionId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "functionId"');
         }
         if (typeof deploymentId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "deploymentId"');
         }
+
         const apiPath = '/functions/{functionId}/deployments/{deploymentId}/status'.replace('{functionId}', functionId).replace('{deploymentId}', deploymentId);
         const payload: Payload = {};
         const uri = new URL(this.client.config.endpoint + apiPath);
@@ -831,20 +1521,56 @@ export class Functions {
     /**
      * 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} params.functionId - Function ID.
+     * @param {string[]} params.queries - Array of query strings generated using the Query class provided by the SDK. [Learn more about queries](https://appwrite.io/docs/queries). Maximum of 100 queries are allowed, each 4096 characters long. You may filter on the following attributes: trigger, status, responseStatusCode, duration, requestMethod, requestPath, deploymentId
+     * @param {boolean} params.total - When set to false, the total count returned will be 0 and will not be calculated.
      * @throws {AppwriteException}
      * @returns {Promise<Models.ExecutionList>}
      */
-    listExecutions(functionId: string, queries?: string[]): Promise<Models.ExecutionList> {
+    listExecutions(params: { functionId: string, queries?: string[], total?: boolean  }): Promise<Models.ExecutionList>;
+    /**
+     * Get a list of all the current user function execution logs. You can use the query params to filter your results.
+     *
+     * @param {string} functionId - Function ID.
+     * @param {string[]} queries - Array of query strings generated using the Query class provided by the SDK. [Learn more about queries](https://appwrite.io/docs/queries). Maximum of 100 queries are allowed, each 4096 characters long. You may filter on the following attributes: trigger, status, responseStatusCode, duration, requestMethod, requestPath, deploymentId
+     * @param {boolean} total - When set to false, the total count returned will be 0 and will not be calculated.
+     * @throws {AppwriteException}
+     * @returns {Promise<Models.ExecutionList>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    listExecutions(functionId: string, queries?: string[], total?: boolean): Promise<Models.ExecutionList>;
+    listExecutions(
+        paramsOrFirst: { functionId: string, queries?: string[], total?: boolean } | string,
+        ...rest: [(string[])?, (boolean)?]    
+    ): Promise<Models.ExecutionList> {
+        let params: { functionId: string, queries?: string[], total?: boolean };
+        
+        if ((paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst))) {
+            params = (paramsOrFirst || {}) as { functionId: string, queries?: string[], total?: boolean };
+        } else {
+            params = {
+                functionId: paramsOrFirst as string,
+                queries: rest[0] as string[],
+                total: rest[1] as boolean            
+            };
+        }
+        
+        const functionId = params.functionId;
+        const queries = params.queries;
+        const total = params.total;
+
         if (typeof functionId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "functionId"');
         }
+
         const apiPath = '/functions/{functionId}/executions'.replace('{functionId}', functionId);
         const payload: Payload = {};
         if (typeof queries !== 'undefined') {
             payload['queries'] = queries;
         }
+        if (typeof total !== 'undefined') {
+            payload['total'] = total;
+        }
         const uri = new URL(this.client.config.endpoint + apiPath);
 
         const apiHeaders: { [header: string]: string } = {
@@ -861,20 +1587,64 @@ export class Functions {
     /**
      * 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} xpath
-     * @param {ExecutionMethod} method
-     * @param {object} headers
-     * @param {string} scheduledAt
+     * @param {string} params.functionId - Function ID.
+     * @param {string} params.body - HTTP body of execution. Default value is empty string.
+     * @param {boolean} params.async - Execute code in the background. Default value is false.
+     * @param {string} params.xpath - HTTP path of execution. Path can include query params. Default value is /
+     * @param {ExecutionMethod} params.method - HTTP method of execution. Default value is POST.
+     * @param {object} params.headers - HTTP headers of execution. Defaults to empty.
+     * @param {string} params.scheduledAt - Scheduled execution time in [ISO 8601](https://www.iso.org/iso-8601-date-and-time-format.html) format. DateTime value must be in future with precision in minutes.
+     * @throws {AppwriteException}
+     * @returns {Promise<Models.Execution>}
+     */
+    createExecution(params: { functionId: string, body?: string, async?: boolean, xpath?: string, method?: ExecutionMethod, headers?: object, scheduledAt?: string  }): Promise<Models.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 - Function ID.
+     * @param {string} body - HTTP body of execution. Default value is empty string.
+     * @param {boolean} async - Execute code in the background. Default value is false.
+     * @param {string} xpath - HTTP path of execution. Path can include query params. Default value is /
+     * @param {ExecutionMethod} method - HTTP method of execution. Default value is POST.
+     * @param {object} headers - HTTP headers of execution. Defaults to empty.
+     * @param {string} scheduledAt - Scheduled execution time in [ISO 8601](https://www.iso.org/iso-8601-date-and-time-format.html) format. DateTime value must be in future with precision in minutes.
      * @throws {AppwriteException}
      * @returns {Promise<Models.Execution>}
+     * @deprecated Use the object parameter style method for a better developer experience.
      */
-    createExecution(functionId: string, body?: string, async?: boolean, xpath?: string, method?: ExecutionMethod, headers?: object, scheduledAt?: string): Promise<Models.Execution> {
+    createExecution(functionId: string, body?: string, async?: boolean, xpath?: string, method?: ExecutionMethod, headers?: object, scheduledAt?: string): Promise<Models.Execution>;
+    createExecution(
+        paramsOrFirst: { functionId: string, body?: string, async?: boolean, xpath?: string, method?: ExecutionMethod, headers?: object, scheduledAt?: string } | string,
+        ...rest: [(string)?, (boolean)?, (string)?, (ExecutionMethod)?, (object)?, (string)?]    
+    ): Promise<Models.Execution> {
+        let params: { functionId: string, body?: string, async?: boolean, xpath?: string, method?: ExecutionMethod, headers?: object, scheduledAt?: string };
+        
+        if ((paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst))) {
+            params = (paramsOrFirst || {}) as { functionId: string, body?: string, async?: boolean, xpath?: string, method?: ExecutionMethod, headers?: object, scheduledAt?: string };
+        } else {
+            params = {
+                functionId: paramsOrFirst as string,
+                body: rest[0] as string,
+                async: rest[1] as boolean,
+                xpath: rest[2] as string,
+                method: rest[3] as ExecutionMethod,
+                headers: rest[4] as object,
+                scheduledAt: rest[5] as string            
+            };
+        }
+        
+        const functionId = params.functionId;
+        const body = params.body;
+        const async = params.async;
+        const xpath = params.xpath;
+        const method = params.method;
+        const headers = params.headers;
+        const scheduledAt = params.scheduledAt;
+
         if (typeof functionId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "functionId"');
         }
+
         const apiPath = '/functions/{functionId}/executions'.replace('{functionId}', functionId);
         const payload: Payload = {};
         if (typeof body !== 'undefined') {
@@ -912,18 +1682,47 @@ export class Functions {
     /**
      * Get a function execution log by its unique ID.
      *
-     * @param {string} functionId
-     * @param {string} executionId
+     * @param {string} params.functionId - Function ID.
+     * @param {string} params.executionId - Execution ID.
+     * @throws {AppwriteException}
+     * @returns {Promise<Models.Execution>}
+     */
+    getExecution(params: { functionId: string, executionId: string  }): Promise<Models.Execution>;
+    /**
+     * Get a function execution log by its unique ID.
+     *
+     * @param {string} functionId - Function ID.
+     * @param {string} executionId - Execution ID.
      * @throws {AppwriteException}
      * @returns {Promise<Models.Execution>}
+     * @deprecated Use the object parameter style method for a better developer experience.
      */
-    getExecution(functionId: string, executionId: string): Promise<Models.Execution> {
+    getExecution(functionId: string, executionId: string): Promise<Models.Execution>;
+    getExecution(
+        paramsOrFirst: { functionId: string, executionId: string } | string,
+        ...rest: [(string)?]    
+    ): Promise<Models.Execution> {
+        let params: { functionId: string, executionId: string };
+        
+        if ((paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst))) {
+            params = (paramsOrFirst || {}) as { functionId: string, executionId: string };
+        } else {
+            params = {
+                functionId: paramsOrFirst as string,
+                executionId: rest[0] as string            
+            };
+        }
+        
+        const functionId = params.functionId;
+        const executionId = params.executionId;
+
         if (typeof functionId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "functionId"');
         }
         if (typeof executionId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "executionId"');
         }
+
         const apiPath = '/functions/{functionId}/executions/{executionId}'.replace('{functionId}', functionId).replace('{executionId}', executionId);
         const payload: Payload = {};
         const uri = new URL(this.client.config.endpoint + apiPath);
@@ -942,18 +1741,47 @@ export class Functions {
     /**
      * Delete a function execution by its unique ID.
      *
-     * @param {string} functionId
-     * @param {string} executionId
+     * @param {string} params.functionId - Function ID.
+     * @param {string} params.executionId - Execution ID.
      * @throws {AppwriteException}
      * @returns {Promise<{}>}
      */
-    deleteExecution(functionId: string, executionId: string): Promise<{}> {
+    deleteExecution(params: { functionId: string, executionId: string  }): Promise<{}>;
+    /**
+     * Delete a function execution by its unique ID.
+     *
+     * @param {string} functionId - Function ID.
+     * @param {string} executionId - Execution ID.
+     * @throws {AppwriteException}
+     * @returns {Promise<{}>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    deleteExecution(functionId: string, executionId: string): Promise<{}>;
+    deleteExecution(
+        paramsOrFirst: { functionId: string, executionId: string } | string,
+        ...rest: [(string)?]    
+    ): Promise<{}> {
+        let params: { functionId: string, executionId: string };
+        
+        if ((paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst))) {
+            params = (paramsOrFirst || {}) as { functionId: string, executionId: string };
+        } else {
+            params = {
+                functionId: paramsOrFirst as string,
+                executionId: rest[0] as string            
+            };
+        }
+        
+        const functionId = params.functionId;
+        const executionId = params.executionId;
+
         if (typeof functionId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "functionId"');
         }
         if (typeof executionId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "executionId"');
         }
+
         const apiPath = '/functions/{functionId}/executions/{executionId}'.replace('{functionId}', functionId).replace('{executionId}', executionId);
         const payload: Payload = {};
         const uri = new URL(this.client.config.endpoint + apiPath);
@@ -973,15 +1801,44 @@ export class Functions {
     /**
      * Get usage metrics and statistics for a for a specific function. View statistics including total deployments, builds, executions, storage usage, and compute time. The response includes both current totals and historical data for each metric. Use the optional range parameter to specify the time window for historical data: 24h (last 24 hours), 30d (last 30 days), or 90d (last 90 days). If not specified, defaults to 30 days.
      *
-     * @param {string} functionId
-     * @param {FunctionUsageRange} range
+     * @param {string} params.functionId - Function ID.
+     * @param {UsageRange} params.range - Date range.
+     * @throws {AppwriteException}
+     * @returns {Promise<Models.UsageFunction>}
+     */
+    getUsage(params: { functionId: string, range?: UsageRange  }): Promise<Models.UsageFunction>;
+    /**
+     * Get usage metrics and statistics for a for a specific function. View statistics including total deployments, builds, executions, storage usage, and compute time. The response includes both current totals and historical data for each metric. Use the optional range parameter to specify the time window for historical data: 24h (last 24 hours), 30d (last 30 days), or 90d (last 90 days). If not specified, defaults to 30 days.
+     *
+     * @param {string} functionId - Function ID.
+     * @param {UsageRange} range - Date range.
      * @throws {AppwriteException}
      * @returns {Promise<Models.UsageFunction>}
+     * @deprecated Use the object parameter style method for a better developer experience.
      */
-    getUsage(functionId: string, range?: FunctionUsageRange): Promise<Models.UsageFunction> {
+    getUsage(functionId: string, range?: UsageRange): Promise<Models.UsageFunction>;
+    getUsage(
+        paramsOrFirst: { functionId: string, range?: UsageRange } | string,
+        ...rest: [(UsageRange)?]    
+    ): Promise<Models.UsageFunction> {
+        let params: { functionId: string, range?: UsageRange };
+        
+        if ((paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst))) {
+            params = (paramsOrFirst || {}) as { functionId: string, range?: UsageRange };
+        } else {
+            params = {
+                functionId: paramsOrFirst as string,
+                range: rest[0] as UsageRange            
+            };
+        }
+        
+        const functionId = params.functionId;
+        const range = params.range;
+
         if (typeof functionId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "functionId"');
         }
+
         const apiPath = '/functions/{functionId}/usage'.replace('{functionId}', functionId);
         const payload: Payload = {};
         if (typeof range !== 'undefined') {
@@ -1003,14 +1860,39 @@ export class Functions {
     /**
      * Get a list of all variables of a specific function.
      *
-     * @param {string} functionId
+     * @param {string} params.functionId - Function unique ID.
+     * @throws {AppwriteException}
+     * @returns {Promise<Models.VariableList>}
+     */
+    listVariables(params: { functionId: string  }): Promise<Models.VariableList>;
+    /**
+     * Get a list of all variables of a specific function.
+     *
+     * @param {string} functionId - Function unique ID.
      * @throws {AppwriteException}
      * @returns {Promise<Models.VariableList>}
+     * @deprecated Use the object parameter style method for a better developer experience.
      */
-    listVariables(functionId: string): Promise<Models.VariableList> {
+    listVariables(functionId: string): Promise<Models.VariableList>;
+    listVariables(
+        paramsOrFirst: { functionId: string } | string    
+    ): Promise<Models.VariableList> {
+        let params: { functionId: string };
+        
+        if ((paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst))) {
+            params = (paramsOrFirst || {}) as { functionId: string };
+        } else {
+            params = {
+                functionId: paramsOrFirst as string            
+            };
+        }
+        
+        const functionId = params.functionId;
+
         if (typeof functionId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "functionId"');
         }
+
         const apiPath = '/functions/{functionId}/variables'.replace('{functionId}', functionId);
         const payload: Payload = {};
         const uri = new URL(this.client.config.endpoint + apiPath);
@@ -1029,14 +1911,48 @@ export class Functions {
     /**
      * 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
-     * @param {boolean} secret
+     * @param {string} params.functionId - Function unique ID.
+     * @param {string} params.key - Variable key. Max length: 255 chars.
+     * @param {string} params.value - Variable value. Max length: 8192 chars.
+     * @param {boolean} params.secret - Secret variables can be updated or deleted, but only functions can read them during build and runtime.
      * @throws {AppwriteException}
      * @returns {Promise<Models.Variable>}
      */
-    createVariable(functionId: string, key: string, value: string, secret?: boolean): Promise<Models.Variable> {
+    createVariable(params: { functionId: string, key: string, value: string, secret?: boolean  }): Promise<Models.Variable>;
+    /**
+     * Create a new function environment variable. These variables can be accessed in the function at runtime as environment variables.
+     *
+     * @param {string} functionId - Function unique ID.
+     * @param {string} key - Variable key. Max length: 255 chars.
+     * @param {string} value - Variable value. Max length: 8192 chars.
+     * @param {boolean} secret - Secret variables can be updated or deleted, but only functions can read them during build and runtime.
+     * @throws {AppwriteException}
+     * @returns {Promise<Models.Variable>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    createVariable(functionId: string, key: string, value: string, secret?: boolean): Promise<Models.Variable>;
+    createVariable(
+        paramsOrFirst: { functionId: string, key: string, value: string, secret?: boolean } | string,
+        ...rest: [(string)?, (string)?, (boolean)?]    
+    ): Promise<Models.Variable> {
+        let params: { functionId: string, key: string, value: string, secret?: boolean };
+        
+        if ((paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst))) {
+            params = (paramsOrFirst || {}) as { functionId: string, key: string, value: string, secret?: boolean };
+        } else {
+            params = {
+                functionId: paramsOrFirst as string,
+                key: rest[0] as string,
+                value: rest[1] as string,
+                secret: rest[2] as boolean            
+            };
+        }
+        
+        const functionId = params.functionId;
+        const key = params.key;
+        const value = params.value;
+        const secret = params.secret;
+
         if (typeof functionId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "functionId"');
         }
@@ -1046,6 +1962,7 @@ export class Functions {
         if (typeof value === 'undefined') {
             throw new AppwriteException('Missing required parameter: "value"');
         }
+
         const apiPath = '/functions/{functionId}/variables'.replace('{functionId}', functionId);
         const payload: Payload = {};
         if (typeof key !== 'undefined') {
@@ -1074,18 +1991,47 @@ export class Functions {
     /**
      * Get a variable by its unique ID.
      *
-     * @param {string} functionId
-     * @param {string} variableId
+     * @param {string} params.functionId - Function unique ID.
+     * @param {string} params.variableId - Variable unique ID.
+     * @throws {AppwriteException}
+     * @returns {Promise<Models.Variable>}
+     */
+    getVariable(params: { functionId: string, variableId: string  }): Promise<Models.Variable>;
+    /**
+     * Get a variable by its unique ID.
+     *
+     * @param {string} functionId - Function unique ID.
+     * @param {string} variableId - Variable unique ID.
      * @throws {AppwriteException}
      * @returns {Promise<Models.Variable>}
+     * @deprecated Use the object parameter style method for a better developer experience.
      */
-    getVariable(functionId: string, variableId: string): Promise<Models.Variable> {
+    getVariable(functionId: string, variableId: string): Promise<Models.Variable>;
+    getVariable(
+        paramsOrFirst: { functionId: string, variableId: string } | string,
+        ...rest: [(string)?]    
+    ): Promise<Models.Variable> {
+        let params: { functionId: string, variableId: string };
+        
+        if ((paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst))) {
+            params = (paramsOrFirst || {}) as { functionId: string, variableId: string };
+        } else {
+            params = {
+                functionId: paramsOrFirst as string,
+                variableId: rest[0] as string            
+            };
+        }
+        
+        const functionId = params.functionId;
+        const variableId = params.variableId;
+
         if (typeof functionId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "functionId"');
         }
         if (typeof variableId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "variableId"');
         }
+
         const apiPath = '/functions/{functionId}/variables/{variableId}'.replace('{functionId}', functionId).replace('{variableId}', variableId);
         const payload: Payload = {};
         const uri = new URL(this.client.config.endpoint + apiPath);
@@ -1104,15 +2050,52 @@ export class Functions {
     /**
      * Update variable by its unique ID.
      *
-     * @param {string} functionId
-     * @param {string} variableId
-     * @param {string} key
-     * @param {string} value
-     * @param {boolean} secret
+     * @param {string} params.functionId - Function unique ID.
+     * @param {string} params.variableId - Variable unique ID.
+     * @param {string} params.key - Variable key. Max length: 255 chars.
+     * @param {string} params.value - Variable value. Max length: 8192 chars.
+     * @param {boolean} params.secret - Secret variables can be updated or deleted, but only functions can read them during build and runtime.
+     * @throws {AppwriteException}
+     * @returns {Promise<Models.Variable>}
+     */
+    updateVariable(params: { functionId: string, variableId: string, key: string, value?: string, secret?: boolean  }): Promise<Models.Variable>;
+    /**
+     * Update variable by its unique ID.
+     *
+     * @param {string} functionId - Function unique ID.
+     * @param {string} variableId - Variable unique ID.
+     * @param {string} key - Variable key. Max length: 255 chars.
+     * @param {string} value - Variable value. Max length: 8192 chars.
+     * @param {boolean} secret - Secret variables can be updated or deleted, but only functions can read them during build and runtime.
      * @throws {AppwriteException}
      * @returns {Promise<Models.Variable>}
+     * @deprecated Use the object parameter style method for a better developer experience.
      */
-    updateVariable(functionId: string, variableId: string, key: string, value?: string, secret?: boolean): Promise<Models.Variable> {
+    updateVariable(functionId: string, variableId: string, key: string, value?: string, secret?: boolean): Promise<Models.Variable>;
+    updateVariable(
+        paramsOrFirst: { functionId: string, variableId: string, key: string, value?: string, secret?: boolean } | string,
+        ...rest: [(string)?, (string)?, (string)?, (boolean)?]    
+    ): Promise<Models.Variable> {
+        let params: { functionId: string, variableId: string, key: string, value?: string, secret?: boolean };
+        
+        if ((paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst))) {
+            params = (paramsOrFirst || {}) as { functionId: string, variableId: string, key: string, value?: string, secret?: boolean };
+        } else {
+            params = {
+                functionId: paramsOrFirst as string,
+                variableId: rest[0] as string,
+                key: rest[1] as string,
+                value: rest[2] as string,
+                secret: rest[3] as boolean            
+            };
+        }
+        
+        const functionId = params.functionId;
+        const variableId = params.variableId;
+        const key = params.key;
+        const value = params.value;
+        const secret = params.secret;
+
         if (typeof functionId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "functionId"');
         }
@@ -1122,6 +2105,7 @@ export class Functions {
         if (typeof key === 'undefined') {
             throw new AppwriteException('Missing required parameter: "key"');
         }
+
         const apiPath = '/functions/{functionId}/variables/{variableId}'.replace('{functionId}', functionId).replace('{variableId}', variableId);
         const payload: Payload = {};
         if (typeof key !== 'undefined') {
@@ -1150,18 +2134,47 @@ export class Functions {
     /**
      * Delete a variable by its unique ID.
      *
-     * @param {string} functionId
-     * @param {string} variableId
+     * @param {string} params.functionId - Function unique ID.
+     * @param {string} params.variableId - Variable unique ID.
+     * @throws {AppwriteException}
+     * @returns {Promise<{}>}
+     */
+    deleteVariable(params: { functionId: string, variableId: string  }): Promise<{}>;
+    /**
+     * Delete a variable by its unique ID.
+     *
+     * @param {string} functionId - Function unique ID.
+     * @param {string} variableId - Variable unique ID.
      * @throws {AppwriteException}
      * @returns {Promise<{}>}
+     * @deprecated Use the object parameter style method for a better developer experience.
      */
-    deleteVariable(functionId: string, variableId: string): Promise<{}> {
+    deleteVariable(functionId: string, variableId: string): Promise<{}>;
+    deleteVariable(
+        paramsOrFirst: { functionId: string, variableId: string } | string,
+        ...rest: [(string)?]    
+    ): Promise<{}> {
+        let params: { functionId: string, variableId: string };
+        
+        if ((paramsOrFirst && typeof paramsOrFirst === 'object' && !Array.isArray(paramsOrFirst))) {
+            params = (paramsOrFirst || {}) as { functionId: string, variableId: string };
+        } else {
+            params = {
+                functionId: paramsOrFirst as string,
+                variableId: rest[0] as string            
+            };
+        }
+        
+        const functionId = params.functionId;
+        const variableId = params.variableId;
+
         if (typeof functionId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "functionId"');
         }
         if (typeof variableId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "variableId"');
         }
+
         const apiPath = '/functions/{functionId}/variables/{variableId}'.replace('{functionId}', functionId).replace('{variableId}', variableId);
         const payload: Payload = {};
         const uri = new URL(this.client.config.endpoint + apiPath);