node-appwrite 17.2.0 → 19.0.0

package/dist/services/databases.mjs

@@ -5,15 +5,18 @@ var Databases = class {
   constructor(client) {
     this.client = client;
   }
-  /**
-   * Get a list of all databases from the current Appwrite project. You can use the search parameter to filter your results.
-   *
-   * @param {string[]} queries
-   * @param {string} search
-   * @throws {AppwriteException}
-   * @returns {Promise<Models.DatabaseList>}
-   */
-  list(queries, search) {
+  list(paramsOrFirst, ...rest) {
+    let params;
+    if (!paramsOrFirst || paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        queries: paramsOrFirst,
+        search: rest[0]
+      };
+    }
+    const queries = params.queries;
+    const search = params.search;
     const apiPath = "/databases";
     const payload = {};
     if (typeof queries !== "undefined") {
@@ -31,17 +34,20 @@ var Databases = class {
       payload
     );
   }
-  /**
-   * Create a new Database.
-   * 
-   *
-   * @param {string} databaseId
-   * @param {string} name
-   * @param {boolean} enabled
-   * @throws {AppwriteException}
-   * @returns {Promise<Models.Database>}
-   */
-  create(databaseId, name, enabled) {
+  create(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        name: rest[0],
+        enabled: rest[1]
+      };
+    }
+    const databaseId = params.databaseId;
+    const name = params.name;
+    const enabled = params.enabled;
     if (typeof databaseId === "undefined") {
       throw new AppwriteException('Missing required parameter: "databaseId"');
     }
@@ -70,14 +76,16 @@ var Databases = class {
       payload
     );
   }
-  /**
-   * Get a database by its unique ID. This endpoint response returns a JSON object with the database metadata.
-   *
-   * @param {string} databaseId
-   * @throws {AppwriteException}
-   * @returns {Promise<Models.Database>}
-   */
-  get(databaseId) {
+  get(paramsOrFirst) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst
+      };
+    }
+    const databaseId = params.databaseId;
     if (typeof databaseId === "undefined") {
       throw new AppwriteException('Missing required parameter: "databaseId"');
     }
@@ -92,16 +100,20 @@ var Databases = class {
       payload
     );
   }
-  /**
-   * Update a database by its unique ID.
-   *
-   * @param {string} databaseId
-   * @param {string} name
-   * @param {boolean} enabled
-   * @throws {AppwriteException}
-   * @returns {Promise<Models.Database>}
-   */
-  update(databaseId, name, enabled) {
+  update(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        name: rest[0],
+        enabled: rest[1]
+      };
+    }
+    const databaseId = params.databaseId;
+    const name = params.name;
+    const enabled = params.enabled;
     if (typeof databaseId === "undefined") {
       throw new AppwriteException('Missing required parameter: "databaseId"');
     }
@@ -127,14 +139,16 @@ var Databases = class {
       payload
     );
   }
-  /**
-   * Delete a database by its unique ID. Only API keys with with databases.write scope can delete a database.
-   *
-   * @param {string} databaseId
-   * @throws {AppwriteException}
-   * @returns {Promise<{}>}
-   */
-  delete(databaseId) {
+  delete(paramsOrFirst) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst
+      };
+    }
+    const databaseId = params.databaseId;
     if (typeof databaseId === "undefined") {
       throw new AppwriteException('Missing required parameter: "databaseId"');
     }
@@ -151,16 +165,20 @@ var Databases = class {
       payload
     );
   }
-  /**
-   * Get a list of all collections that belong to the provided databaseId. You can use the search parameter to filter your results.
-   *
-   * @param {string} databaseId
-   * @param {string[]} queries
-   * @param {string} search
-   * @throws {AppwriteException}
-   * @returns {Promise<Models.CollectionList>}
-   */
-  listCollections(databaseId, queries, search) {
+  listCollections(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        queries: rest[0],
+        search: rest[1]
+      };
+    }
+    const databaseId = params.databaseId;
+    const queries = params.queries;
+    const search = params.search;
     if (typeof databaseId === "undefined") {
       throw new AppwriteException('Missing required parameter: "databaseId"');
     }
@@ -181,19 +199,26 @@ var Databases = class {
       payload
     );
   }
-  /**
-   * Create a new Collection. Before using this route, you should create a new database resource using either a [server integration](https://appwrite.io/docs/server/databases#databasesCreateCollection) API or directly from your database console.
-   *
-   * @param {string} databaseId
-   * @param {string} collectionId
-   * @param {string} name
-   * @param {string[]} permissions
-   * @param {boolean} documentSecurity
-   * @param {boolean} enabled
-   * @throws {AppwriteException}
-   * @returns {Promise<Models.Collection>}
-   */
-  createCollection(databaseId, collectionId, name, permissions, documentSecurity, enabled) {
+  createCollection(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        collectionId: rest[0],
+        name: rest[1],
+        permissions: rest[2],
+        documentSecurity: rest[3],
+        enabled: rest[4]
+      };
+    }
+    const databaseId = params.databaseId;
+    const collectionId = params.collectionId;
+    const name = params.name;
+    const permissions = params.permissions;
+    const documentSecurity = params.documentSecurity;
+    const enabled = params.enabled;
     if (typeof databaseId === "undefined") {
       throw new AppwriteException('Missing required parameter: "databaseId"');
     }
@@ -231,15 +256,18 @@ var Databases = class {
       payload
     );
   }
-  /**
-   * Get a collection by its unique ID. This endpoint response returns a JSON object with the collection metadata.
-   *
-   * @param {string} databaseId
-   * @param {string} collectionId
-   * @throws {AppwriteException}
-   * @returns {Promise<Models.Collection>}
-   */
-  getCollection(databaseId, collectionId) {
+  getCollection(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        collectionId: rest[0]
+      };
+    }
+    const databaseId = params.databaseId;
+    const collectionId = params.collectionId;
     if (typeof databaseId === "undefined") {
       throw new AppwriteException('Missing required parameter: "databaseId"');
     }
@@ -257,19 +285,26 @@ var Databases = class {
       payload
     );
   }
-  /**
-   * Update a collection by its unique ID.
-   *
-   * @param {string} databaseId
-   * @param {string} collectionId
-   * @param {string} name
-   * @param {string[]} permissions
-   * @param {boolean} documentSecurity
-   * @param {boolean} enabled
-   * @throws {AppwriteException}
-   * @returns {Promise<Models.Collection>}
-   */
-  updateCollection(databaseId, collectionId, name, permissions, documentSecurity, enabled) {
+  updateCollection(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        collectionId: rest[0],
+        name: rest[1],
+        permissions: rest[2],
+        documentSecurity: rest[3],
+        enabled: rest[4]
+      };
+    }
+    const databaseId = params.databaseId;
+    const collectionId = params.collectionId;
+    const name = params.name;
+    const permissions = params.permissions;
+    const documentSecurity = params.documentSecurity;
+    const enabled = params.enabled;
     if (typeof databaseId === "undefined") {
       throw new AppwriteException('Missing required parameter: "databaseId"');
     }
@@ -304,15 +339,18 @@ var Databases = class {
       payload
     );
   }
-  /**
-   * Delete a collection by its unique ID. Only users with write permissions have access to delete this resource.
-   *
-   * @param {string} databaseId
-   * @param {string} collectionId
-   * @throws {AppwriteException}
-   * @returns {Promise<{}>}
-   */
-  deleteCollection(databaseId, collectionId) {
+  deleteCollection(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        collectionId: rest[0]
+      };
+    }
+    const databaseId = params.databaseId;
+    const collectionId = params.collectionId;
     if (typeof databaseId === "undefined") {
       throw new AppwriteException('Missing required parameter: "databaseId"');
     }
@@ -332,16 +370,20 @@ var Databases = class {
       payload
     );
   }
-  /**
-   * List attributes in the collection.
-   *
-   * @param {string} databaseId
-   * @param {string} collectionId
-   * @param {string[]} queries
-   * @throws {AppwriteException}
-   * @returns {Promise<Models.AttributeList>}
-   */
-  listAttributes(databaseId, collectionId, queries) {
+  listAttributes(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        collectionId: rest[0],
+        queries: rest[1]
+      };
+    }
+    const databaseId = params.databaseId;
+    const collectionId = params.collectionId;
+    const queries = params.queries;
     if (typeof databaseId === "undefined") {
       throw new AppwriteException('Missing required parameter: "databaseId"');
     }
@@ -362,20 +404,26 @@ var Databases = class {
       payload
     );
   }
-  /**
-   * Create a boolean attribute.
-   * 
-   *
-   * @param {string} databaseId
-   * @param {string} collectionId
-   * @param {string} key
-   * @param {boolean} required
-   * @param {boolean} xdefault
-   * @param {boolean} array
-   * @throws {AppwriteException}
-   * @returns {Promise<Models.AttributeBoolean>}
-   */
-  createBooleanAttribute(databaseId, collectionId, key, required, xdefault, array) {
+  createBooleanAttribute(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        collectionId: rest[0],
+        key: rest[1],
+        required: rest[2],
+        xdefault: rest[3],
+        array: rest[4]
+      };
+    }
+    const databaseId = params.databaseId;
+    const collectionId = params.collectionId;
+    const key = params.key;
+    const required = params.required;
+    const xdefault = params.xdefault;
+    const array = params.array;
     if (typeof databaseId === "undefined") {
       throw new AppwriteException('Missing required parameter: "databaseId"');
     }
@@ -413,19 +461,26 @@ var Databases = class {
       payload
     );
   }
-  /**
-   * Update a boolean attribute. Changing the `default` value will not update already existing documents.
-   *
-   * @param {string} databaseId
-   * @param {string} collectionId
-   * @param {string} key
-   * @param {boolean} required
-   * @param {boolean} xdefault
-   * @param {string} newKey
-   * @throws {AppwriteException}
-   * @returns {Promise<Models.AttributeBoolean>}
-   */
-  updateBooleanAttribute(databaseId, collectionId, key, required, xdefault, newKey) {
+  updateBooleanAttribute(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        collectionId: rest[0],
+        key: rest[1],
+        required: rest[2],
+        xdefault: rest[3],
+        newKey: rest[4]
+      };
+    }
+    const databaseId = params.databaseId;
+    const collectionId = params.collectionId;
+    const key = params.key;
+    const required = params.required;
+    const xdefault = params.xdefault;
+    const newKey = params.newKey;
     if (typeof databaseId === "undefined") {
       throw new AppwriteException('Missing required parameter: "databaseId"');
     }
@@ -463,19 +518,26 @@ var Databases = class {
       payload
     );
   }
-  /**
-   * Create a date time attribute according to the ISO 8601 standard.
-   *
-   * @param {string} databaseId
-   * @param {string} collectionId
-   * @param {string} key
-   * @param {boolean} required
-   * @param {string} xdefault
-   * @param {boolean} array
-   * @throws {AppwriteException}
-   * @returns {Promise<Models.AttributeDatetime>}
-   */
-  createDatetimeAttribute(databaseId, collectionId, key, required, xdefault, array) {
+  createDatetimeAttribute(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        collectionId: rest[0],
+        key: rest[1],
+        required: rest[2],
+        xdefault: rest[3],
+        array: rest[4]
+      };
+    }
+    const databaseId = params.databaseId;
+    const collectionId = params.collectionId;
+    const key = params.key;
+    const required = params.required;
+    const xdefault = params.xdefault;
+    const array = params.array;
     if (typeof databaseId === "undefined") {
       throw new AppwriteException('Missing required parameter: "databaseId"');
     }
@@ -513,19 +575,26 @@ var Databases = class {
       payload
     );
   }
-  /**
-   * Update a date time attribute. Changing the `default` value will not update already existing documents.
-   *
-   * @param {string} databaseId
-   * @param {string} collectionId
-   * @param {string} key
-   * @param {boolean} required
-   * @param {string} xdefault
-   * @param {string} newKey
-   * @throws {AppwriteException}
-   * @returns {Promise<Models.AttributeDatetime>}
-   */
-  updateDatetimeAttribute(databaseId, collectionId, key, required, xdefault, newKey) {
+  updateDatetimeAttribute(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        collectionId: rest[0],
+        key: rest[1],
+        required: rest[2],
+        xdefault: rest[3],
+        newKey: rest[4]
+      };
+    }
+    const databaseId = params.databaseId;
+    const collectionId = params.collectionId;
+    const key = params.key;
+    const required = params.required;
+    const xdefault = params.xdefault;
+    const newKey = params.newKey;
     if (typeof databaseId === "undefined") {
       throw new AppwriteException('Missing required parameter: "databaseId"');
     }
@@ -563,20 +632,26 @@ var Databases = class {
       payload
     );
   }
-  /**
-   * Create an email attribute.
-   * 
-   *
-   * @param {string} databaseId
-   * @param {string} collectionId
-   * @param {string} key
-   * @param {boolean} required
-   * @param {string} xdefault
-   * @param {boolean} array
-   * @throws {AppwriteException}
-   * @returns {Promise<Models.AttributeEmail>}
-   */
-  createEmailAttribute(databaseId, collectionId, key, required, xdefault, array) {
+  createEmailAttribute(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        collectionId: rest[0],
+        key: rest[1],
+        required: rest[2],
+        xdefault: rest[3],
+        array: rest[4]
+      };
+    }
+    const databaseId = params.databaseId;
+    const collectionId = params.collectionId;
+    const key = params.key;
+    const required = params.required;
+    const xdefault = params.xdefault;
+    const array = params.array;
     if (typeof databaseId === "undefined") {
       throw new AppwriteException('Missing required parameter: "databaseId"');
     }
@@ -614,20 +689,26 @@ var Databases = class {
       payload
     );
   }
-  /**
-   * Update an email attribute. Changing the `default` value will not update already existing documents.
-   * 
-   *
-   * @param {string} databaseId
-   * @param {string} collectionId
-   * @param {string} key
-   * @param {boolean} required
-   * @param {string} xdefault
-   * @param {string} newKey
-   * @throws {AppwriteException}
-   * @returns {Promise<Models.AttributeEmail>}
-   */
-  updateEmailAttribute(databaseId, collectionId, key, required, xdefault, newKey) {
+  updateEmailAttribute(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        collectionId: rest[0],
+        key: rest[1],
+        required: rest[2],
+        xdefault: rest[3],
+        newKey: rest[4]
+      };
+    }
+    const databaseId = params.databaseId;
+    const collectionId = params.collectionId;
+    const key = params.key;
+    const required = params.required;
+    const xdefault = params.xdefault;
+    const newKey = params.newKey;
     if (typeof databaseId === "undefined") {
       throw new AppwriteException('Missing required parameter: "databaseId"');
     }
@@ -665,21 +746,28 @@ var Databases = class {
       payload
     );
   }
-  /**
-   * Create an enumeration attribute. The `elements` param acts as a white-list of accepted values for this attribute. 
-   * 
-   *
-   * @param {string} databaseId
-   * @param {string} collectionId
-   * @param {string} key
-   * @param {string[]} elements
-   * @param {boolean} required
-   * @param {string} xdefault
-   * @param {boolean} array
-   * @throws {AppwriteException}
-   * @returns {Promise<Models.AttributeEnum>}
-   */
-  createEnumAttribute(databaseId, collectionId, key, elements, required, xdefault, array) {
+  createEnumAttribute(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        collectionId: rest[0],
+        key: rest[1],
+        elements: rest[2],
+        required: rest[3],
+        xdefault: rest[4],
+        array: rest[5]
+      };
+    }
+    const databaseId = params.databaseId;
+    const collectionId = params.collectionId;
+    const key = params.key;
+    const elements = params.elements;
+    const required = params.required;
+    const xdefault = params.xdefault;
+    const array = params.array;
     if (typeof databaseId === "undefined") {
       throw new AppwriteException('Missing required parameter: "databaseId"');
     }
@@ -723,21 +811,28 @@ var Databases = class {
       payload
     );
   }
-  /**
-   * Update an enum attribute. Changing the `default` value will not update already existing documents.
-   * 
-   *
-   * @param {string} databaseId
-   * @param {string} collectionId
-   * @param {string} key
-   * @param {string[]} elements
-   * @param {boolean} required
-   * @param {string} xdefault
-   * @param {string} newKey
-   * @throws {AppwriteException}
-   * @returns {Promise<Models.AttributeEnum>}
-   */
-  updateEnumAttribute(databaseId, collectionId, key, elements, required, xdefault, newKey) {
+  updateEnumAttribute(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        collectionId: rest[0],
+        key: rest[1],
+        elements: rest[2],
+        required: rest[3],
+        xdefault: rest[4],
+        newKey: rest[5]
+      };
+    }
+    const databaseId = params.databaseId;
+    const collectionId = params.collectionId;
+    const key = params.key;
+    const elements = params.elements;
+    const required = params.required;
+    const xdefault = params.xdefault;
+    const newKey = params.newKey;
     if (typeof databaseId === "undefined") {
       throw new AppwriteException('Missing required parameter: "databaseId"');
     }
@@ -781,22 +876,30 @@ var Databases = class {
       payload
     );
   }
-  /**
-   * Create a float attribute. Optionally, minimum and maximum values can be provided.
-   * 
-   *
-   * @param {string} databaseId
-   * @param {string} collectionId
-   * @param {string} key
-   * @param {boolean} required
-   * @param {number} min
-   * @param {number} max
-   * @param {number} xdefault
-   * @param {boolean} array
-   * @throws {AppwriteException}
-   * @returns {Promise<Models.AttributeFloat>}
-   */
-  createFloatAttribute(databaseId, collectionId, key, required, min, max, xdefault, array) {
+  createFloatAttribute(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        collectionId: rest[0],
+        key: rest[1],
+        required: rest[2],
+        min: rest[3],
+        max: rest[4],
+        xdefault: rest[5],
+        array: rest[6]
+      };
+    }
+    const databaseId = params.databaseId;
+    const collectionId = params.collectionId;
+    const key = params.key;
+    const required = params.required;
+    const min = params.min;
+    const max = params.max;
+    const xdefault = params.xdefault;
+    const array = params.array;
     if (typeof databaseId === "undefined") {
       throw new AppwriteException('Missing required parameter: "databaseId"');
     }
@@ -840,22 +943,30 @@ var Databases = class {
       payload
     );
   }
-  /**
-   * Update a float attribute. Changing the `default` value will not update already existing documents.
-   * 
-   *
-   * @param {string} databaseId
-   * @param {string} collectionId
-   * @param {string} key
-   * @param {boolean} required
-   * @param {number} xdefault
-   * @param {number} min
-   * @param {number} max
-   * @param {string} newKey
-   * @throws {AppwriteException}
-   * @returns {Promise<Models.AttributeFloat>}
-   */
-  updateFloatAttribute(databaseId, collectionId, key, required, xdefault, min, max, newKey) {
+  updateFloatAttribute(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        collectionId: rest[0],
+        key: rest[1],
+        required: rest[2],
+        xdefault: rest[3],
+        min: rest[4],
+        max: rest[5],
+        newKey: rest[6]
+      };
+    }
+    const databaseId = params.databaseId;
+    const collectionId = params.collectionId;
+    const key = params.key;
+    const required = params.required;
+    const xdefault = params.xdefault;
+    const min = params.min;
+    const max = params.max;
+    const newKey = params.newKey;
     if (typeof databaseId === "undefined") {
       throw new AppwriteException('Missing required parameter: "databaseId"');
     }
@@ -899,22 +1010,30 @@ var Databases = class {
       payload
     );
   }
-  /**
-   * Create an integer attribute. Optionally, minimum and maximum values can be provided.
-   * 
-   *
-   * @param {string} databaseId
-   * @param {string} collectionId
-   * @param {string} key
-   * @param {boolean} required
-   * @param {number} min
-   * @param {number} max
-   * @param {number} xdefault
-   * @param {boolean} array
-   * @throws {AppwriteException}
-   * @returns {Promise<Models.AttributeInteger>}
-   */
-  createIntegerAttribute(databaseId, collectionId, key, required, min, max, xdefault, array) {
+  createIntegerAttribute(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        collectionId: rest[0],
+        key: rest[1],
+        required: rest[2],
+        min: rest[3],
+        max: rest[4],
+        xdefault: rest[5],
+        array: rest[6]
+      };
+    }
+    const databaseId = params.databaseId;
+    const collectionId = params.collectionId;
+    const key = params.key;
+    const required = params.required;
+    const min = params.min;
+    const max = params.max;
+    const xdefault = params.xdefault;
+    const array = params.array;
     if (typeof databaseId === "undefined") {
       throw new AppwriteException('Missing required parameter: "databaseId"');
     }
@@ -958,22 +1077,30 @@ var Databases = class {
       payload
     );
   }
-  /**
-   * Update an integer attribute. Changing the `default` value will not update already existing documents.
-   * 
-   *
-   * @param {string} databaseId
-   * @param {string} collectionId
-   * @param {string} key
-   * @param {boolean} required
-   * @param {number} xdefault
-   * @param {number} min
-   * @param {number} max
-   * @param {string} newKey
-   * @throws {AppwriteException}
-   * @returns {Promise<Models.AttributeInteger>}
-   */
-  updateIntegerAttribute(databaseId, collectionId, key, required, xdefault, min, max, newKey) {
+  updateIntegerAttribute(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        collectionId: rest[0],
+        key: rest[1],
+        required: rest[2],
+        xdefault: rest[3],
+        min: rest[4],
+        max: rest[5],
+        newKey: rest[6]
+      };
+    }
+    const databaseId = params.databaseId;
+    const collectionId = params.collectionId;
+    const key = params.key;
+    const required = params.required;
+    const xdefault = params.xdefault;
+    const min = params.min;
+    const max = params.max;
+    const newKey = params.newKey;
     if (typeof databaseId === "undefined") {
       throw new AppwriteException('Missing required parameter: "databaseId"');
     }
@@ -1017,20 +1144,26 @@ var Databases = class {
       payload
     );
   }
-  /**
-   * Create IP address attribute.
-   * 
-   *
-   * @param {string} databaseId
-   * @param {string} collectionId
-   * @param {string} key
-   * @param {boolean} required
-   * @param {string} xdefault
-   * @param {boolean} array
-   * @throws {AppwriteException}
-   * @returns {Promise<Models.AttributeIp>}
-   */
-  createIpAttribute(databaseId, collectionId, key, required, xdefault, array) {
+  createIpAttribute(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        collectionId: rest[0],
+        key: rest[1],
+        required: rest[2],
+        xdefault: rest[3],
+        array: rest[4]
+      };
+    }
+    const databaseId = params.databaseId;
+    const collectionId = params.collectionId;
+    const key = params.key;
+    const required = params.required;
+    const xdefault = params.xdefault;
+    const array = params.array;
     if (typeof databaseId === "undefined") {
       throw new AppwriteException('Missing required parameter: "databaseId"');
     }
@@ -1068,20 +1201,26 @@ var Databases = class {
       payload
     );
   }
-  /**
-   * Update an ip attribute. Changing the `default` value will not update already existing documents.
-   * 
-   *
-   * @param {string} databaseId
-   * @param {string} collectionId
-   * @param {string} key
-   * @param {boolean} required
-   * @param {string} xdefault
-   * @param {string} newKey
-   * @throws {AppwriteException}
-   * @returns {Promise<Models.AttributeIp>}
-   */
-  updateIpAttribute(databaseId, collectionId, key, required, xdefault, newKey) {
+  updateIpAttribute(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        collectionId: rest[0],
+        key: rest[1],
+        required: rest[2],
+        xdefault: rest[3],
+        newKey: rest[4]
+      };
+    }
+    const databaseId = params.databaseId;
+    const collectionId = params.collectionId;
+    const key = params.key;
+    const required = params.required;
+    const xdefault = params.xdefault;
+    const newKey = params.newKey;
     if (typeof databaseId === "undefined") {
       throw new AppwriteException('Missing required parameter: "databaseId"');
     }
@@ -1119,22 +1258,348 @@ var Databases = class {
       payload
     );
   }
-  /**
-   * Create relationship attribute. [Learn more about relationship attributes](https://appwrite.io/docs/databases-relationships#relationship-attributes).
-   * 
-   *
-   * @param {string} databaseId
-   * @param {string} collectionId
-   * @param {string} relatedCollectionId
-   * @param {RelationshipType} type
-   * @param {boolean} twoWay
-   * @param {string} key
-   * @param {string} twoWayKey
-   * @param {RelationMutate} onDelete
-   * @throws {AppwriteException}
-   * @returns {Promise<Models.AttributeRelationship>}
-   */
-  createRelationshipAttribute(databaseId, collectionId, relatedCollectionId, type, twoWay, key, twoWayKey, onDelete) {
+  createLineAttribute(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        collectionId: rest[0],
+        key: rest[1],
+        required: rest[2],
+        xdefault: rest[3]
+      };
+    }
+    const databaseId = params.databaseId;
+    const collectionId = params.collectionId;
+    const key = params.key;
+    const required = params.required;
+    const xdefault = params.xdefault;
+    if (typeof databaseId === "undefined") {
+      throw new AppwriteException('Missing required parameter: "databaseId"');
+    }
+    if (typeof collectionId === "undefined") {
+      throw new AppwriteException('Missing required parameter: "collectionId"');
+    }
+    if (typeof key === "undefined") {
+      throw new AppwriteException('Missing required parameter: "key"');
+    }
+    if (typeof required === "undefined") {
+      throw new AppwriteException('Missing required parameter: "required"');
+    }
+    const apiPath = "/databases/{databaseId}/collections/{collectionId}/attributes/line".replace("{databaseId}", databaseId).replace("{collectionId}", collectionId);
+    const payload = {};
+    if (typeof key !== "undefined") {
+      payload["key"] = key;
+    }
+    if (typeof required !== "undefined") {
+      payload["required"] = required;
+    }
+    if (typeof xdefault !== "undefined") {
+      payload["default"] = xdefault;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {
+      "content-type": "application/json"
+    };
+    return this.client.call(
+      "post",
+      uri,
+      apiHeaders,
+      payload
+    );
+  }
+  updateLineAttribute(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        collectionId: rest[0],
+        key: rest[1],
+        required: rest[2],
+        xdefault: rest[3],
+        newKey: rest[4]
+      };
+    }
+    const databaseId = params.databaseId;
+    const collectionId = params.collectionId;
+    const key = params.key;
+    const required = params.required;
+    const xdefault = params.xdefault;
+    const newKey = params.newKey;
+    if (typeof databaseId === "undefined") {
+      throw new AppwriteException('Missing required parameter: "databaseId"');
+    }
+    if (typeof collectionId === "undefined") {
+      throw new AppwriteException('Missing required parameter: "collectionId"');
+    }
+    if (typeof key === "undefined") {
+      throw new AppwriteException('Missing required parameter: "key"');
+    }
+    if (typeof required === "undefined") {
+      throw new AppwriteException('Missing required parameter: "required"');
+    }
+    const apiPath = "/databases/{databaseId}/collections/{collectionId}/attributes/line/{key}".replace("{databaseId}", databaseId).replace("{collectionId}", collectionId).replace("{key}", key);
+    const payload = {};
+    if (typeof required !== "undefined") {
+      payload["required"] = required;
+    }
+    if (typeof xdefault !== "undefined") {
+      payload["default"] = xdefault;
+    }
+    if (typeof newKey !== "undefined") {
+      payload["newKey"] = newKey;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {
+      "content-type": "application/json"
+    };
+    return this.client.call(
+      "patch",
+      uri,
+      apiHeaders,
+      payload
+    );
+  }
+  createPointAttribute(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        collectionId: rest[0],
+        key: rest[1],
+        required: rest[2],
+        xdefault: rest[3]
+      };
+    }
+    const databaseId = params.databaseId;
+    const collectionId = params.collectionId;
+    const key = params.key;
+    const required = params.required;
+    const xdefault = params.xdefault;
+    if (typeof databaseId === "undefined") {
+      throw new AppwriteException('Missing required parameter: "databaseId"');
+    }
+    if (typeof collectionId === "undefined") {
+      throw new AppwriteException('Missing required parameter: "collectionId"');
+    }
+    if (typeof key === "undefined") {
+      throw new AppwriteException('Missing required parameter: "key"');
+    }
+    if (typeof required === "undefined") {
+      throw new AppwriteException('Missing required parameter: "required"');
+    }
+    const apiPath = "/databases/{databaseId}/collections/{collectionId}/attributes/point".replace("{databaseId}", databaseId).replace("{collectionId}", collectionId);
+    const payload = {};
+    if (typeof key !== "undefined") {
+      payload["key"] = key;
+    }
+    if (typeof required !== "undefined") {
+      payload["required"] = required;
+    }
+    if (typeof xdefault !== "undefined") {
+      payload["default"] = xdefault;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {
+      "content-type": "application/json"
+    };
+    return this.client.call(
+      "post",
+      uri,
+      apiHeaders,
+      payload
+    );
+  }
+  updatePointAttribute(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        collectionId: rest[0],
+        key: rest[1],
+        required: rest[2],
+        xdefault: rest[3],
+        newKey: rest[4]
+      };
+    }
+    const databaseId = params.databaseId;
+    const collectionId = params.collectionId;
+    const key = params.key;
+    const required = params.required;
+    const xdefault = params.xdefault;
+    const newKey = params.newKey;
+    if (typeof databaseId === "undefined") {
+      throw new AppwriteException('Missing required parameter: "databaseId"');
+    }
+    if (typeof collectionId === "undefined") {
+      throw new AppwriteException('Missing required parameter: "collectionId"');
+    }
+    if (typeof key === "undefined") {
+      throw new AppwriteException('Missing required parameter: "key"');
+    }
+    if (typeof required === "undefined") {
+      throw new AppwriteException('Missing required parameter: "required"');
+    }
+    const apiPath = "/databases/{databaseId}/collections/{collectionId}/attributes/point/{key}".replace("{databaseId}", databaseId).replace("{collectionId}", collectionId).replace("{key}", key);
+    const payload = {};
+    if (typeof required !== "undefined") {
+      payload["required"] = required;
+    }
+    if (typeof xdefault !== "undefined") {
+      payload["default"] = xdefault;
+    }
+    if (typeof newKey !== "undefined") {
+      payload["newKey"] = newKey;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {
+      "content-type": "application/json"
+    };
+    return this.client.call(
+      "patch",
+      uri,
+      apiHeaders,
+      payload
+    );
+  }
+  createPolygonAttribute(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        collectionId: rest[0],
+        key: rest[1],
+        required: rest[2],
+        xdefault: rest[3]
+      };
+    }
+    const databaseId = params.databaseId;
+    const collectionId = params.collectionId;
+    const key = params.key;
+    const required = params.required;
+    const xdefault = params.xdefault;
+    if (typeof databaseId === "undefined") {
+      throw new AppwriteException('Missing required parameter: "databaseId"');
+    }
+    if (typeof collectionId === "undefined") {
+      throw new AppwriteException('Missing required parameter: "collectionId"');
+    }
+    if (typeof key === "undefined") {
+      throw new AppwriteException('Missing required parameter: "key"');
+    }
+    if (typeof required === "undefined") {
+      throw new AppwriteException('Missing required parameter: "required"');
+    }
+    const apiPath = "/databases/{databaseId}/collections/{collectionId}/attributes/polygon".replace("{databaseId}", databaseId).replace("{collectionId}", collectionId);
+    const payload = {};
+    if (typeof key !== "undefined") {
+      payload["key"] = key;
+    }
+    if (typeof required !== "undefined") {
+      payload["required"] = required;
+    }
+    if (typeof xdefault !== "undefined") {
+      payload["default"] = xdefault;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {
+      "content-type": "application/json"
+    };
+    return this.client.call(
+      "post",
+      uri,
+      apiHeaders,
+      payload
+    );
+  }
+  updatePolygonAttribute(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        collectionId: rest[0],
+        key: rest[1],
+        required: rest[2],
+        xdefault: rest[3],
+        newKey: rest[4]
+      };
+    }
+    const databaseId = params.databaseId;
+    const collectionId = params.collectionId;
+    const key = params.key;
+    const required = params.required;
+    const xdefault = params.xdefault;
+    const newKey = params.newKey;
+    if (typeof databaseId === "undefined") {
+      throw new AppwriteException('Missing required parameter: "databaseId"');
+    }
+    if (typeof collectionId === "undefined") {
+      throw new AppwriteException('Missing required parameter: "collectionId"');
+    }
+    if (typeof key === "undefined") {
+      throw new AppwriteException('Missing required parameter: "key"');
+    }
+    if (typeof required === "undefined") {
+      throw new AppwriteException('Missing required parameter: "required"');
+    }
+    const apiPath = "/databases/{databaseId}/collections/{collectionId}/attributes/polygon/{key}".replace("{databaseId}", databaseId).replace("{collectionId}", collectionId).replace("{key}", key);
+    const payload = {};
+    if (typeof required !== "undefined") {
+      payload["required"] = required;
+    }
+    if (typeof xdefault !== "undefined") {
+      payload["default"] = xdefault;
+    }
+    if (typeof newKey !== "undefined") {
+      payload["newKey"] = newKey;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {
+      "content-type": "application/json"
+    };
+    return this.client.call(
+      "patch",
+      uri,
+      apiHeaders,
+      payload
+    );
+  }
+  createRelationshipAttribute(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        collectionId: rest[0],
+        relatedCollectionId: rest[1],
+        type: rest[2],
+        twoWay: rest[3],
+        key: rest[4],
+        twoWayKey: rest[5],
+        onDelete: rest[6]
+      };
+    }
+    const databaseId = params.databaseId;
+    const collectionId = params.collectionId;
+    const relatedCollectionId = params.relatedCollectionId;
+    const type = params.type;
+    const twoWay = params.twoWay;
+    const key = params.key;
+    const twoWayKey = params.twoWayKey;
+    const onDelete = params.onDelete;
     if (typeof databaseId === "undefined") {
       throw new AppwriteException('Missing required parameter: "databaseId"');
     }
@@ -1178,22 +1643,30 @@ var Databases = class {
       payload
     );
   }
-  /**
-   * Create a string attribute.
-   * 
-   *
-   * @param {string} databaseId
-   * @param {string} collectionId
-   * @param {string} key
-   * @param {number} size
-   * @param {boolean} required
-   * @param {string} xdefault
-   * @param {boolean} array
-   * @param {boolean} encrypt
-   * @throws {AppwriteException}
-   * @returns {Promise<Models.AttributeString>}
-   */
-  createStringAttribute(databaseId, collectionId, key, size, required, xdefault, array, encrypt) {
+  createStringAttribute(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        collectionId: rest[0],
+        key: rest[1],
+        size: rest[2],
+        required: rest[3],
+        xdefault: rest[4],
+        array: rest[5],
+        encrypt: rest[6]
+      };
+    }
+    const databaseId = params.databaseId;
+    const collectionId = params.collectionId;
+    const key = params.key;
+    const size = params.size;
+    const required = params.required;
+    const xdefault = params.xdefault;
+    const array = params.array;
+    const encrypt = params.encrypt;
     if (typeof databaseId === "undefined") {
       throw new AppwriteException('Missing required parameter: "databaseId"');
     }
@@ -1240,21 +1713,28 @@ var Databases = class {
       payload
     );
   }
-  /**
-   * Update a string attribute. Changing the `default` value will not update already existing documents.
-   * 
-   *
-   * @param {string} databaseId
-   * @param {string} collectionId
-   * @param {string} key
-   * @param {boolean} required
-   * @param {string} xdefault
-   * @param {number} size
-   * @param {string} newKey
-   * @throws {AppwriteException}
-   * @returns {Promise<Models.AttributeString>}
-   */
-  updateStringAttribute(databaseId, collectionId, key, required, xdefault, size, newKey) {
+  updateStringAttribute(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        collectionId: rest[0],
+        key: rest[1],
+        required: rest[2],
+        xdefault: rest[3],
+        size: rest[4],
+        newKey: rest[5]
+      };
+    }
+    const databaseId = params.databaseId;
+    const collectionId = params.collectionId;
+    const key = params.key;
+    const required = params.required;
+    const xdefault = params.xdefault;
+    const size = params.size;
+    const newKey = params.newKey;
     if (typeof databaseId === "undefined") {
       throw new AppwriteException('Missing required parameter: "databaseId"');
     }
@@ -1295,20 +1775,26 @@ var Databases = class {
       payload
     );
   }
-  /**
-   * Create a URL attribute.
-   * 
-   *
-   * @param {string} databaseId
-   * @param {string} collectionId
-   * @param {string} key
-   * @param {boolean} required
-   * @param {string} xdefault
-   * @param {boolean} array
-   * @throws {AppwriteException}
-   * @returns {Promise<Models.AttributeUrl>}
-   */
-  createUrlAttribute(databaseId, collectionId, key, required, xdefault, array) {
+  createUrlAttribute(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        collectionId: rest[0],
+        key: rest[1],
+        required: rest[2],
+        xdefault: rest[3],
+        array: rest[4]
+      };
+    }
+    const databaseId = params.databaseId;
+    const collectionId = params.collectionId;
+    const key = params.key;
+    const required = params.required;
+    const xdefault = params.xdefault;
+    const array = params.array;
     if (typeof databaseId === "undefined") {
       throw new AppwriteException('Missing required parameter: "databaseId"');
     }
@@ -1346,20 +1832,26 @@ var Databases = class {
       payload
     );
   }
-  /**
-   * Update an url attribute. Changing the `default` value will not update already existing documents.
-   * 
-   *
-   * @param {string} databaseId
-   * @param {string} collectionId
-   * @param {string} key
-   * @param {boolean} required
-   * @param {string} xdefault
-   * @param {string} newKey
-   * @throws {AppwriteException}
-   * @returns {Promise<Models.AttributeUrl>}
-   */
-  updateUrlAttribute(databaseId, collectionId, key, required, xdefault, newKey) {
+  updateUrlAttribute(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        collectionId: rest[0],
+        key: rest[1],
+        required: rest[2],
+        xdefault: rest[3],
+        newKey: rest[4]
+      };
+    }
+    const databaseId = params.databaseId;
+    const collectionId = params.collectionId;
+    const key = params.key;
+    const required = params.required;
+    const xdefault = params.xdefault;
+    const newKey = params.newKey;
     if (typeof databaseId === "undefined") {
       throw new AppwriteException('Missing required parameter: "databaseId"');
     }
@@ -1397,16 +1889,20 @@ var Databases = class {
       payload
     );
   }
-  /**
-   * Get attribute by ID.
-   *
-   * @param {string} databaseId
-   * @param {string} collectionId
-   * @param {string} key
-   * @throws {AppwriteException}
-   * @returns {Promise<{}>}
-   */
-  getAttribute(databaseId, collectionId, key) {
+  getAttribute(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        collectionId: rest[0],
+        key: rest[1]
+      };
+    }
+    const databaseId = params.databaseId;
+    const collectionId = params.collectionId;
+    const key = params.key;
     if (typeof databaseId === "undefined") {
       throw new AppwriteException('Missing required parameter: "databaseId"');
     }
@@ -1427,16 +1923,20 @@ var Databases = class {
       payload
     );
   }
-  /**
-   * Deletes an attribute.
-   *
-   * @param {string} databaseId
-   * @param {string} collectionId
-   * @param {string} key
-   * @throws {AppwriteException}
-   * @returns {Promise<{}>}
-   */
-  deleteAttribute(databaseId, collectionId, key) {
+  deleteAttribute(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        collectionId: rest[0],
+        key: rest[1]
+      };
+    }
+    const databaseId = params.databaseId;
+    const collectionId = params.collectionId;
+    const key = params.key;
     if (typeof databaseId === "undefined") {
       throw new AppwriteException('Missing required parameter: "databaseId"');
     }
@@ -1459,19 +1959,24 @@ var Databases = class {
       payload
     );
   }
-  /**
-   * Update relationship attribute. [Learn more about relationship attributes](https://appwrite.io/docs/databases-relationships#relationship-attributes).
-   * 
-   *
-   * @param {string} databaseId
-   * @param {string} collectionId
-   * @param {string} key
-   * @param {RelationMutate} onDelete
-   * @param {string} newKey
-   * @throws {AppwriteException}
-   * @returns {Promise<Models.AttributeRelationship>}
-   */
-  updateRelationshipAttribute(databaseId, collectionId, key, onDelete, newKey) {
+  updateRelationshipAttribute(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        collectionId: rest[0],
+        key: rest[1],
+        onDelete: rest[2],
+        newKey: rest[3]
+      };
+    }
+    const databaseId = params.databaseId;
+    const collectionId = params.collectionId;
+    const key = params.key;
+    const onDelete = params.onDelete;
+    const newKey = params.newKey;
     if (typeof databaseId === "undefined") {
       throw new AppwriteException('Missing required parameter: "databaseId"');
     }
@@ -1500,16 +2005,20 @@ var Databases = class {
       payload
     );
   }
-  /**
-   * Get a list of all the user&#039;s documents in a given collection. You can use the query params to filter your results.
-   *
-   * @param {string} databaseId
-   * @param {string} collectionId
-   * @param {string[]} queries
-   * @throws {AppwriteException}
-   * @returns {Promise<Models.DocumentList<Document>>}
-   */
-  listDocuments(databaseId, collectionId, queries) {
+  listDocuments(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        collectionId: rest[0],
+        queries: rest[1]
+      };
+    }
+    const databaseId = params.databaseId;
+    const collectionId = params.collectionId;
+    const queries = params.queries;
     if (typeof databaseId === "undefined") {
       throw new AppwriteException('Missing required parameter: "databaseId"');
     }
@@ -1530,18 +2039,24 @@ var Databases = class {
       payload
     );
   }
-  /**
-   * Create a new Document. Before using this route, you should create a new collection resource using either a [server integration](https://appwrite.io/docs/server/databases#databasesCreateCollection) API or directly from your database console.
-   *
-   * @param {string} databaseId
-   * @param {string} collectionId
-   * @param {string} documentId
-   * @param {Document extends Models.DefaultDocument ? Models.DataWithoutDocumentKeys : Omit<Document, keyof Models.Document>} data
-   * @param {string[]} permissions
-   * @throws {AppwriteException}
-   * @returns {Promise<Document>}
-   */
-  createDocument(databaseId, collectionId, documentId, data, permissions) {
+  createDocument(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        collectionId: rest[0],
+        documentId: rest[1],
+        data: rest[2],
+        permissions: rest[3]
+      };
+    }
+    const databaseId = params.databaseId;
+    const collectionId = params.collectionId;
+    const documentId = params.documentId;
+    const data = params.data;
+    const permissions = params.permissions;
     if (typeof databaseId === "undefined") {
       throw new AppwriteException('Missing required parameter: "databaseId"');
     }
@@ -1576,18 +2091,20 @@ var Databases = class {
       payload
     );
   }
-  /**
-   * **WARNING: Experimental Feature** - This endpoint is experimental and not yet officially supported. It may be subject to breaking changes or removal in future versions.
-   * 
-   * Create new Documents. Before using this route, you should create a new collection resource using either a [server integration](https://appwrite.io/docs/server/databases#databasesCreateCollection) API or directly from your database console.
-   *
-   * @param {string} databaseId
-   * @param {string} collectionId
-   * @param {object[]} documents
-   * @throws {AppwriteException}
-   * @returns {Promise<Models.DocumentList<Document>>}
-   */
-  createDocuments(databaseId, collectionId, documents) {
+  createDocuments(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        collectionId: rest[0],
+        documents: rest[1]
+      };
+    }
+    const databaseId = params.databaseId;
+    const collectionId = params.collectionId;
+    const documents = params.documents;
     if (typeof databaseId === "undefined") {
       throw new AppwriteException('Missing required parameter: "databaseId"');
     }
@@ -1613,19 +2130,20 @@ var Databases = class {
       payload
     );
   }
-  /**
-   * **WARNING: Experimental Feature** - This endpoint is experimental and not yet officially supported. It may be subject to breaking changes or removal in future versions.
-   * 
-   * Create or update Documents. Before using this route, you should create a new collection resource using either a [server integration](https://appwrite.io/docs/server/databases#databasesCreateCollection) API or directly from your database console.
-   * 
-   *
-   * @param {string} databaseId
-   * @param {string} collectionId
-   * @param {object[]} documents
-   * @throws {AppwriteException}
-   * @returns {Promise<Models.DocumentList<Document>>}
-   */
-  upsertDocuments(databaseId, collectionId, documents) {
+  upsertDocuments(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        collectionId: rest[0],
+        documents: rest[1]
+      };
+    }
+    const databaseId = params.databaseId;
+    const collectionId = params.collectionId;
+    const documents = params.documents;
     if (typeof databaseId === "undefined") {
       throw new AppwriteException('Missing required parameter: "databaseId"');
     }
@@ -1651,19 +2169,22 @@ var Databases = class {
       payload
     );
   }
-  /**
-   * **WARNING: Experimental Feature** - This endpoint is experimental and not yet officially supported. It may be subject to breaking changes or removal in future versions.
-   * 
-   * Update all documents that match your queries, if no queries are submitted then all documents are updated. You can pass only specific fields to be updated.
-   *
-   * @param {string} databaseId
-   * @param {string} collectionId
-   * @param {object} data
-   * @param {string[]} queries
-   * @throws {AppwriteException}
-   * @returns {Promise<Models.DocumentList<Document>>}
-   */
-  updateDocuments(databaseId, collectionId, data, queries) {
+  updateDocuments(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        collectionId: rest[0],
+        data: rest[1],
+        queries: rest[2]
+      };
+    }
+    const databaseId = params.databaseId;
+    const collectionId = params.collectionId;
+    const data = params.data;
+    const queries = params.queries;
     if (typeof databaseId === "undefined") {
       throw new AppwriteException('Missing required parameter: "databaseId"');
     }
@@ -1689,18 +2210,20 @@ var Databases = class {
       payload
     );
   }
-  /**
-   * **WARNING: Experimental Feature** - This endpoint is experimental and not yet officially supported. It may be subject to breaking changes or removal in future versions.
-   * 
-   * Bulk delete documents using queries, if no queries are passed then all documents are deleted.
-   *
-   * @param {string} databaseId
-   * @param {string} collectionId
-   * @param {string[]} queries
-   * @throws {AppwriteException}
-   * @returns {Promise<Models.DocumentList<Document>>}
-   */
-  deleteDocuments(databaseId, collectionId, queries) {
+  deleteDocuments(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        collectionId: rest[0],
+        queries: rest[1]
+      };
+    }
+    const databaseId = params.databaseId;
+    const collectionId = params.collectionId;
+    const queries = params.queries;
     if (typeof databaseId === "undefined") {
       throw new AppwriteException('Missing required parameter: "databaseId"');
     }
@@ -1723,17 +2246,22 @@ var Databases = class {
       payload
     );
   }
-  /**
-   * Get a document by its unique ID. This endpoint response returns a JSON object with the document data.
-   *
-   * @param {string} databaseId
-   * @param {string} collectionId
-   * @param {string} documentId
-   * @param {string[]} queries
-   * @throws {AppwriteException}
-   * @returns {Promise<Document>}
-   */
-  getDocument(databaseId, collectionId, documentId, queries) {
+  getDocument(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        collectionId: rest[0],
+        documentId: rest[1],
+        queries: rest[2]
+      };
+    }
+    const databaseId = params.databaseId;
+    const collectionId = params.collectionId;
+    const documentId = params.documentId;
+    const queries = params.queries;
     if (typeof databaseId === "undefined") {
       throw new AppwriteException('Missing required parameter: "databaseId"');
     }
@@ -1757,20 +2285,24 @@ var Databases = class {
       payload
     );
   }
-  /**
-   * **WARNING: Experimental Feature** - This endpoint is experimental and not yet officially supported. It may be subject to breaking changes or removal in future versions.
-   * 
-   * Create or update a Document. Before using this route, you should create a new collection resource using either a [server integration](https://appwrite.io/docs/server/databases#databasesCreateCollection) API or directly from your database console.
-   *
-   * @param {string} databaseId
-   * @param {string} collectionId
-   * @param {string} documentId
-   * @param {object} data
-   * @param {string[]} permissions
-   * @throws {AppwriteException}
-   * @returns {Promise<Document>}
-   */
-  upsertDocument(databaseId, collectionId, documentId, data, permissions) {
+  upsertDocument(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        collectionId: rest[0],
+        documentId: rest[1],
+        data: rest[2],
+        permissions: rest[3]
+      };
+    }
+    const databaseId = params.databaseId;
+    const collectionId = params.collectionId;
+    const documentId = params.documentId;
+    const data = params.data;
+    const permissions = params.permissions;
     if (typeof databaseId === "undefined") {
       throw new AppwriteException('Missing required parameter: "databaseId"');
     }
@@ -1802,18 +2334,24 @@ var Databases = class {
       payload
     );
   }
-  /**
-   * Update a document by its unique ID. Using the patch method you can pass only specific fields that will get updated.
-   *
-   * @param {string} databaseId
-   * @param {string} collectionId
-   * @param {string} documentId
-   * @param {Partial<Document extends Models.DefaultDocument ? Models.DataWithoutDocumentKeys : Omit<Document, keyof Models.Document>>} data
-   * @param {string[]} permissions
-   * @throws {AppwriteException}
-   * @returns {Promise<Document>}
-   */
-  updateDocument(databaseId, collectionId, documentId, data, permissions) {
+  updateDocument(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        collectionId: rest[0],
+        documentId: rest[1],
+        data: rest[2],
+        permissions: rest[3]
+      };
+    }
+    const databaseId = params.databaseId;
+    const collectionId = params.collectionId;
+    const documentId = params.documentId;
+    const data = params.data;
+    const permissions = params.permissions;
     if (typeof databaseId === "undefined") {
       throw new AppwriteException('Missing required parameter: "databaseId"');
     }
@@ -1842,16 +2380,20 @@ var Databases = class {
       payload
     );
   }
-  /**
-   * Delete a document by its unique ID.
-   *
-   * @param {string} databaseId
-   * @param {string} collectionId
-   * @param {string} documentId
-   * @throws {AppwriteException}
-   * @returns {Promise<{}>}
-   */
-  deleteDocument(databaseId, collectionId, documentId) {
+  deleteDocument(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        collectionId: rest[0],
+        documentId: rest[1]
+      };
+    }
+    const databaseId = params.databaseId;
+    const collectionId = params.collectionId;
+    const documentId = params.documentId;
     if (typeof databaseId === "undefined") {
       throw new AppwriteException('Missing required parameter: "databaseId"');
     }
@@ -1874,19 +2416,26 @@ var Databases = class {
       payload
     );
   }
-  /**
-   * Decrement a specific attribute of a document by a given value.
-   *
-   * @param {string} databaseId
-   * @param {string} collectionId
-   * @param {string} documentId
-   * @param {string} attribute
-   * @param {number} value
-   * @param {number} min
-   * @throws {AppwriteException}
-   * @returns {Promise<Document>}
-   */
-  decrementDocumentAttribute(databaseId, collectionId, documentId, attribute, value, min) {
+  decrementDocumentAttribute(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        collectionId: rest[0],
+        documentId: rest[1],
+        attribute: rest[2],
+        value: rest[3],
+        min: rest[4]
+      };
+    }
+    const databaseId = params.databaseId;
+    const collectionId = params.collectionId;
+    const documentId = params.documentId;
+    const attribute = params.attribute;
+    const value = params.value;
+    const min = params.min;
     if (typeof databaseId === "undefined") {
       throw new AppwriteException('Missing required parameter: "databaseId"');
     }
@@ -1918,19 +2467,26 @@ var Databases = class {
       payload
     );
   }
-  /**
-   * Increment a specific attribute of a document by a given value.
-   *
-   * @param {string} databaseId
-   * @param {string} collectionId
-   * @param {string} documentId
-   * @param {string} attribute
-   * @param {number} value
-   * @param {number} max
-   * @throws {AppwriteException}
-   * @returns {Promise<Document>}
-   */
-  incrementDocumentAttribute(databaseId, collectionId, documentId, attribute, value, max) {
+  incrementDocumentAttribute(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        collectionId: rest[0],
+        documentId: rest[1],
+        attribute: rest[2],
+        value: rest[3],
+        max: rest[4]
+      };
+    }
+    const databaseId = params.databaseId;
+    const collectionId = params.collectionId;
+    const documentId = params.documentId;
+    const attribute = params.attribute;
+    const value = params.value;
+    const max = params.max;
     if (typeof databaseId === "undefined") {
       throw new AppwriteException('Missing required parameter: "databaseId"');
     }
@@ -1962,16 +2518,20 @@ var Databases = class {
       payload
     );
   }
-  /**
-   * List indexes in the collection.
-   *
-   * @param {string} databaseId
-   * @param {string} collectionId
-   * @param {string[]} queries
-   * @throws {AppwriteException}
-   * @returns {Promise<Models.IndexList>}
-   */
-  listIndexes(databaseId, collectionId, queries) {
+  listIndexes(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        collectionId: rest[0],
+        queries: rest[1]
+      };
+    }
+    const databaseId = params.databaseId;
+    const collectionId = params.collectionId;
+    const queries = params.queries;
     if (typeof databaseId === "undefined") {
       throw new AppwriteException('Missing required parameter: "databaseId"');
     }
@@ -1992,21 +2552,28 @@ var Databases = class {
       payload
     );
   }
-  /**
-   * Creates an index on the attributes listed. Your index should include all the attributes you will query in a single request.
-   * Attributes can be `key`, `fulltext`, and `unique`.
-   *
-   * @param {string} databaseId
-   * @param {string} collectionId
-   * @param {string} key
-   * @param {IndexType} type
-   * @param {string[]} attributes
-   * @param {string[]} orders
-   * @param {number[]} lengths
-   * @throws {AppwriteException}
-   * @returns {Promise<Models.Index>}
-   */
-  createIndex(databaseId, collectionId, key, type, attributes, orders, lengths) {
+  createIndex(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        collectionId: rest[0],
+        key: rest[1],
+        type: rest[2],
+        attributes: rest[3],
+        orders: rest[4],
+        lengths: rest[5]
+      };
+    }
+    const databaseId = params.databaseId;
+    const collectionId = params.collectionId;
+    const key = params.key;
+    const type = params.type;
+    const attributes = params.attributes;
+    const orders = params.orders;
+    const lengths = params.lengths;
     if (typeof databaseId === "undefined") {
       throw new AppwriteException('Missing required parameter: "databaseId"');
     }
@@ -2050,16 +2617,20 @@ var Databases = class {
       payload
     );
   }
-  /**
-   * Get index by ID.
-   *
-   * @param {string} databaseId
-   * @param {string} collectionId
-   * @param {string} key
-   * @throws {AppwriteException}
-   * @returns {Promise<Models.Index>}
-   */
-  getIndex(databaseId, collectionId, key) {
+  getIndex(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        collectionId: rest[0],
+        key: rest[1]
+      };
+    }
+    const databaseId = params.databaseId;
+    const collectionId = params.collectionId;
+    const key = params.key;
     if (typeof databaseId === "undefined") {
       throw new AppwriteException('Missing required parameter: "databaseId"');
     }
@@ -2080,16 +2651,20 @@ var Databases = class {
       payload
     );
   }
-  /**
-   * Delete an index.
-   *
-   * @param {string} databaseId
-   * @param {string} collectionId
-   * @param {string} key
-   * @throws {AppwriteException}
-   * @returns {Promise<{}>}
-   */
-  deleteIndex(databaseId, collectionId, key) {
+  deleteIndex(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        databaseId: paramsOrFirst,
+        collectionId: rest[0],
+        key: rest[1]
+      };
+    }
+    const databaseId = params.databaseId;
+    const collectionId = params.collectionId;
+    const key = params.key;
     if (typeof databaseId === "undefined") {
       throw new AppwriteException('Missing required parameter: "databaseId"');
     }