appwrite 5.0.0 → 7.0.0.pre.RC2

data/lib/appwrite/services/databases.rb

@@ -0,0 +1,1425 @@
+#frozen_string_literal: true
+
+module Appwrite
+    class Databases < Service
+
+        def initialize(client)
+            @client = client
+        end
+
+        # Get a list of all databases from the current Appwrite project. You can use
+        # the search parameter to filter your results.
+        #
+        # @param [Array] queries Array of query strings generated using the Query class provided by the SDK. [Learn more about queries](https://appwrite.io/docs/databases#querying-documents). Maximum of 100 queries are allowed, each 4096 characters long. You may filter on the following attributes: name
+        # @param [String] search Search term to filter your list results. Max length: 256 chars.
+        #
+        # @return [DatabaseList]
+        def list(queries: nil, search: nil)
+
+            path = '/databases'
+
+            params = {
+                queries: queries,
+                search: search,
+            }
+            
+            headers = {
+                "content-type": 'application/json',
+            }
+
+            @client.call(
+                method: 'GET',
+                path: path,
+                headers: headers,
+                params: params,
+                response_type: Models::DatabaseList
+            )
+        end
+
+        
+        # Create a new Database.
+        # 
+        #
+        # @param [String] database_id Unique Id. Choose your own unique ID or pass the string "unique()" to auto generate it. 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 Collection name. Max length: 128 chars.
+        #
+        # @return [Database]
+        def create(database_id:, name:)
+
+            path = '/databases'
+
+            params = {
+                databaseId: database_id,
+                name: name,
+            }
+            
+            headers = {
+                "content-type": 'application/json',
+            }
+            if database_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "databaseId"')
+            end
+
+            if name.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "name"')
+            end
+
+
+            @client.call(
+                method: 'POST',
+                path: path,
+                headers: headers,
+                params: params,
+                response_type: Models::Database
+            )
+        end
+
+        
+        # Get a database by its unique ID. This endpoint response returns a JSON
+        # object with the database metadata.
+        #
+        # @param [String] database_id Database ID.
+        #
+        # @return [Database]
+        def get(database_id:)
+
+            path = '/databases/{databaseId}'
+
+            params = {
+            }
+            
+            headers = {
+                "content-type": 'application/json',
+            }
+            if database_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "databaseId"')
+            end
+
+                .gsub('{databaseId}', database_id)
+
+            @client.call(
+                method: 'GET',
+                path: path,
+                headers: headers,
+                params: params,
+                response_type: Models::Database
+            )
+        end
+
+        
+        # Update a database by its unique ID.
+        #
+        # @param [String] database_id Database ID.
+        # @param [String] name Collection name. Max length: 128 chars.
+        #
+        # @return [Database]
+        def update(database_id:, name:)
+
+            path = '/databases/{databaseId}'
+
+            params = {
+                name: name,
+            }
+            
+            headers = {
+                "content-type": 'application/json',
+            }
+            if database_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "databaseId"')
+            end
+
+            if name.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "name"')
+            end
+
+                .gsub('{databaseId}', database_id)
+
+            @client.call(
+                method: 'PUT',
+                path: path,
+                headers: headers,
+                params: params,
+                response_type: Models::Database
+            )
+        end
+
+        
+        # Delete a database by its unique ID. Only API keys with with databases.write
+        # scope can delete a database.
+        #
+        # @param [String] database_id Database ID.
+        #
+        # @return []
+        def delete(database_id:)
+
+            path = '/databases/{databaseId}'
+
+            params = {
+            }
+            
+            headers = {
+                "content-type": 'application/json',
+            }
+            if database_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "databaseId"')
+            end
+
+                .gsub('{databaseId}', database_id)
+
+            @client.call(
+                method: 'DELETE',
+                path: path,
+                headers: headers,
+                params: params,
+            )
+        end
+
+        
+        # Get a list of all collections that belong to the provided databaseId. You
+        # can use the search parameter to filter your results.
+        #
+        # @param [String] database_id Database ID.
+        # @param [Array] queries Array of query strings generated using the Query class provided by the SDK. [Learn more about queries](https://appwrite.io/docs/databases#querying-documents). Maximum of 100 queries are allowed, each 4096 characters long. You may filter on the following attributes: name, enabled, documentSecurity
+        # @param [String] search Search term to filter your list results. Max length: 256 chars.
+        #
+        # @return [CollectionList]
+        def list_collections(database_id:, queries: nil, search: nil)
+
+            path = '/databases/{databaseId}/collections'
+
+            params = {
+                queries: queries,
+                search: search,
+            }
+            
+            headers = {
+                "content-type": 'application/json',
+            }
+            if database_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "databaseId"')
+            end
+
+                .gsub('{databaseId}', database_id)
+
+            @client.call(
+                method: 'GET',
+                path: path,
+                headers: headers,
+                params: params,
+                response_type: Models::CollectionList
+            )
+        end
+
+        
+        # Create a new Collection. Before using this route, you should create a new
+        # database resource using either a [server
+        # integration](/docs/server/databases#databasesCreateCollection) API or
+        # directly from your database console.
+        #
+        # @param [String] database_id Database ID.
+        # @param [String] collection_id Unique Id. Choose your own unique ID or pass the string "unique()" to auto generate it. 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 Collection name. Max length: 128 chars.
+        # @param [Array] permissions An array of permissions strings. By default no user is granted with any permissions. [Learn more about permissions](/docs/permissions).
+        # @param [] document_security Enables configuring permissions for individual documents. A user needs one of document or collection level permissions to access a document. [Learn more about permissions](/docs/permissions).
+        #
+        # @return [Collection]
+        def create_collection(database_id:, collection_id:, name:, permissions: nil, document_security: nil)
+
+            path = '/databases/{databaseId}/collections'
+
+            params = {
+                collectionId: collection_id,
+                name: name,
+                permissions: permissions,
+                documentSecurity: document_security,
+            }
+            
+            headers = {
+                "content-type": 'application/json',
+            }
+            if database_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "databaseId"')
+            end
+
+            if collection_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "collectionId"')
+            end
+
+            if name.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "name"')
+            end
+
+                .gsub('{databaseId}', database_id)
+
+            @client.call(
+                method: 'POST',
+                path: path,
+                headers: headers,
+                params: params,
+                response_type: Models::Collection
+            )
+        end
+
+        
+        # Get a collection by its unique ID. This endpoint response returns a JSON
+        # object with the collection metadata.
+        #
+        # @param [String] database_id Database ID.
+        # @param [String] collection_id Collection ID.
+        #
+        # @return [Collection]
+        def get_collection(database_id:, collection_id:)
+
+            path = '/databases/{databaseId}/collections/{collectionId}'
+
+            params = {
+            }
+            
+            headers = {
+                "content-type": 'application/json',
+            }
+            if database_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "databaseId"')
+            end
+
+            if collection_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "collectionId"')
+            end
+
+                .gsub('{databaseId}', database_id)
+                .gsub('{collectionId}', collection_id)
+
+            @client.call(
+                method: 'GET',
+                path: path,
+                headers: headers,
+                params: params,
+                response_type: Models::Collection
+            )
+        end
+
+        
+        # Update a collection by its unique ID.
+        #
+        # @param [String] database_id Database ID.
+        # @param [String] collection_id Collection ID.
+        # @param [String] name Collection name. Max length: 128 chars.
+        # @param [Array] permissions An array of permission strings. By default the current permission are inherited. [Learn more about permissions](/docs/permissions).
+        # @param [] document_security Enables configuring permissions for individual documents. A user needs one of document or collection level permissions to access a document. [Learn more about permissions](/docs/permissions).
+        # @param [] enabled Is collection enabled?
+        #
+        # @return [Collection]
+        def update_collection(database_id:, collection_id:, name:, permissions: nil, document_security: nil, enabled: nil)
+
+            path = '/databases/{databaseId}/collections/{collectionId}'
+
+            params = {
+                name: name,
+                permissions: permissions,
+                documentSecurity: document_security,
+                enabled: enabled,
+            }
+            
+            headers = {
+                "content-type": 'application/json',
+            }
+            if database_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "databaseId"')
+            end
+
+            if collection_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "collectionId"')
+            end
+
+            if name.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "name"')
+            end
+
+                .gsub('{databaseId}', database_id)
+                .gsub('{collectionId}', collection_id)
+
+            @client.call(
+                method: 'PUT',
+                path: path,
+                headers: headers,
+                params: params,
+                response_type: Models::Collection
+            )
+        end
+
+        
+        # Delete a collection by its unique ID. Only users with write permissions
+        # have access to delete this resource.
+        #
+        # @param [String] database_id Database ID.
+        # @param [String] collection_id Collection ID.
+        #
+        # @return []
+        def delete_collection(database_id:, collection_id:)
+
+            path = '/databases/{databaseId}/collections/{collectionId}'
+
+            params = {
+            }
+            
+            headers = {
+                "content-type": 'application/json',
+            }
+            if database_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "databaseId"')
+            end
+
+            if collection_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "collectionId"')
+            end
+
+                .gsub('{databaseId}', database_id)
+                .gsub('{collectionId}', collection_id)
+
+            @client.call(
+                method: 'DELETE',
+                path: path,
+                headers: headers,
+                params: params,
+            )
+        end
+
+        
+        # 
+        #
+        # @param [String] database_id Database ID.
+        # @param [String] collection_id Collection ID. You can create a new collection using the Database service [server integration](https://appwrite.io/docs/server/databases#databasesCreateCollection).
+        #
+        # @return [AttributeList]
+        def list_attributes(database_id:, collection_id:)
+
+            path = '/databases/{databaseId}/collections/{collectionId}/attributes'
+
+            params = {
+            }
+            
+            headers = {
+                "content-type": 'application/json',
+            }
+            if database_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "databaseId"')
+            end
+
+            if collection_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "collectionId"')
+            end
+
+                .gsub('{databaseId}', database_id)
+                .gsub('{collectionId}', collection_id)
+
+            @client.call(
+                method: 'GET',
+                path: path,
+                headers: headers,
+                params: params,
+                response_type: Models::AttributeList
+            )
+        end
+
+        
+        # Create a boolean attribute.
+        # 
+        #
+        # @param [String] database_id Database ID.
+        # @param [String] collection_id Collection ID. You can create a new collection using the Database service [server integration](https://appwrite.io/docs/server/databases#databasesCreateCollection).
+        # @param [String] key Attribute Key.
+        # @param [] required Is attribute required?
+        # @param [] default Default value for attribute when not provided. Cannot be set when attribute is required.
+        # @param [] array Is attribute an array?
+        #
+        # @return [AttributeBoolean]
+        def create_boolean_attribute(database_id:, collection_id:, key:, required:, default: nil, array: nil)
+
+            path = '/databases/{databaseId}/collections/{collectionId}/attributes/boolean'
+
+            params = {
+                key: key,
+                required: required,
+                default: default,
+                array: array,
+            }
+            
+            headers = {
+                "content-type": 'application/json',
+            }
+            if database_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "databaseId"')
+            end
+
+            if collection_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "collectionId"')
+            end
+
+            if key.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "key"')
+            end
+
+            if required.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "required"')
+            end
+
+                .gsub('{databaseId}', database_id)
+                .gsub('{collectionId}', collection_id)
+
+            @client.call(
+                method: 'POST',
+                path: path,
+                headers: headers,
+                params: params,
+                response_type: Models::AttributeBoolean
+            )
+        end
+
+        
+        # 
+        #
+        # @param [String] database_id Database ID.
+        # @param [String] collection_id Collection ID. You can create a new collection using the Database service [server integration](https://appwrite.io/docs/server/databases#databasesCreateCollection).
+        # @param [String] key Attribute Key.
+        # @param [] required Is attribute required?
+        # @param [String] default Default value for the attribute in ISO 8601 format. Cannot be set when attribute is required.
+        # @param [] array Is attribute an array?
+        #
+        # @return [AttributeDatetime]
+        def create_datetime_attribute(database_id:, collection_id:, key:, required:, default: nil, array: nil)
+
+            path = '/databases/{databaseId}/collections/{collectionId}/attributes/datetime'
+
+            params = {
+                key: key,
+                required: required,
+                default: default,
+                array: array,
+            }
+            
+            headers = {
+                "content-type": 'application/json',
+            }
+            if database_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "databaseId"')
+            end
+
+            if collection_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "collectionId"')
+            end
+
+            if key.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "key"')
+            end
+
+            if required.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "required"')
+            end
+
+                .gsub('{databaseId}', database_id)
+                .gsub('{collectionId}', collection_id)
+
+            @client.call(
+                method: 'POST',
+                path: path,
+                headers: headers,
+                params: params,
+                response_type: Models::AttributeDatetime
+            )
+        end
+
+        
+        # Create an email attribute.
+        # 
+        #
+        # @param [String] database_id Database ID.
+        # @param [String] collection_id Collection ID. You can create a new collection using the Database service [server integration](https://appwrite.io/docs/server/databases#databasesCreateCollection).
+        # @param [String] key Attribute Key.
+        # @param [] required Is attribute required?
+        # @param [String] default Default value for attribute when not provided. Cannot be set when attribute is required.
+        # @param [] array Is attribute an array?
+        #
+        # @return [AttributeEmail]
+        def create_email_attribute(database_id:, collection_id:, key:, required:, default: nil, array: nil)
+
+            path = '/databases/{databaseId}/collections/{collectionId}/attributes/email'
+
+            params = {
+                key: key,
+                required: required,
+                default: default,
+                array: array,
+            }
+            
+            headers = {
+                "content-type": 'application/json',
+            }
+            if database_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "databaseId"')
+            end
+
+            if collection_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "collectionId"')
+            end
+
+            if key.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "key"')
+            end
+
+            if required.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "required"')
+            end
+
+                .gsub('{databaseId}', database_id)
+                .gsub('{collectionId}', collection_id)
+
+            @client.call(
+                method: 'POST',
+                path: path,
+                headers: headers,
+                params: params,
+                response_type: Models::AttributeEmail
+            )
+        end
+
+        
+        # 
+        #
+        # @param [String] database_id Database ID.
+        # @param [String] collection_id Collection ID. You can create a new collection using the Database service [server integration](https://appwrite.io/docs/server/databases#databasesCreateCollection).
+        # @param [String] key Attribute Key.
+        # @param [Array] elements Array of elements in enumerated type. Uses length of longest element to determine size. Maximum of 100 elements are allowed, each 4096 characters long.
+        # @param [] required Is attribute required?
+        # @param [String] default Default value for attribute when not provided. Cannot be set when attribute is required.
+        # @param [] array Is attribute an array?
+        #
+        # @return [AttributeEnum]
+        def create_enum_attribute(database_id:, collection_id:, key:, elements:, required:, default: nil, array: nil)
+
+            path = '/databases/{databaseId}/collections/{collectionId}/attributes/enum'
+
+            params = {
+                key: key,
+                elements: elements,
+                required: required,
+                default: default,
+                array: array,
+            }
+            
+            headers = {
+                "content-type": 'application/json',
+            }
+            if database_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "databaseId"')
+            end
+
+            if collection_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "collectionId"')
+            end
+
+            if key.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "key"')
+            end
+
+            if elements.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "elements"')
+            end
+
+            if required.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "required"')
+            end
+
+                .gsub('{databaseId}', database_id)
+                .gsub('{collectionId}', collection_id)
+
+            @client.call(
+                method: 'POST',
+                path: path,
+                headers: headers,
+                params: params,
+                response_type: Models::AttributeEnum
+            )
+        end
+
+        
+        # Create a float attribute. Optionally, minimum and maximum values can be
+        # provided.
+        # 
+        #
+        # @param [String] database_id Database ID.
+        # @param [String] collection_id Collection ID. You can create a new collection using the Database service [server integration](https://appwrite.io/docs/server/databases#databasesCreateCollection).
+        # @param [String] key Attribute Key.
+        # @param [] required Is attribute required?
+        # @param [Float] min Minimum value to enforce on new documents
+        # @param [Float] max Maximum value to enforce on new documents
+        # @param [Float] default Default value for attribute when not provided. Cannot be set when attribute is required.
+        # @param [] array Is attribute an array?
+        #
+        # @return [AttributeFloat]
+        def create_float_attribute(database_id:, collection_id:, key:, required:, min: nil, max: nil, default: nil, array: nil)
+
+            path = '/databases/{databaseId}/collections/{collectionId}/attributes/float'
+
+            params = {
+                key: key,
+                required: required,
+                min: min,
+                max: max,
+                default: default,
+                array: array,
+            }
+            
+            headers = {
+                "content-type": 'application/json',
+            }
+            if database_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "databaseId"')
+            end
+
+            if collection_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "collectionId"')
+            end
+
+            if key.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "key"')
+            end
+
+            if required.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "required"')
+            end
+
+                .gsub('{databaseId}', database_id)
+                .gsub('{collectionId}', collection_id)
+
+            @client.call(
+                method: 'POST',
+                path: path,
+                headers: headers,
+                params: params,
+                response_type: Models::AttributeFloat
+            )
+        end
+
+        
+        # Create an integer attribute. Optionally, minimum and maximum values can be
+        # provided.
+        # 
+        #
+        # @param [String] database_id Database ID.
+        # @param [String] collection_id Collection ID. You can create a new collection using the Database service [server integration](https://appwrite.io/docs/server/databases#databasesCreateCollection).
+        # @param [String] key Attribute Key.
+        # @param [] required Is attribute required?
+        # @param [Integer] min Minimum value to enforce on new documents
+        # @param [Integer] max Maximum value to enforce on new documents
+        # @param [Integer] default Default value for attribute when not provided. Cannot be set when attribute is required.
+        # @param [] array Is attribute an array?
+        #
+        # @return [AttributeInteger]
+        def create_integer_attribute(database_id:, collection_id:, key:, required:, min: nil, max: nil, default: nil, array: nil)
+
+            path = '/databases/{databaseId}/collections/{collectionId}/attributes/integer'
+
+            params = {
+                key: key,
+                required: required,
+                min: min,
+                max: max,
+                default: default,
+                array: array,
+            }
+            
+            headers = {
+                "content-type": 'application/json',
+            }
+            if database_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "databaseId"')
+            end
+
+            if collection_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "collectionId"')
+            end
+
+            if key.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "key"')
+            end
+
+            if required.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "required"')
+            end
+
+                .gsub('{databaseId}', database_id)
+                .gsub('{collectionId}', collection_id)
+
+            @client.call(
+                method: 'POST',
+                path: path,
+                headers: headers,
+                params: params,
+                response_type: Models::AttributeInteger
+            )
+        end
+
+        
+        # Create IP address attribute.
+        # 
+        #
+        # @param [String] database_id Database ID.
+        # @param [String] collection_id Collection ID. You can create a new collection using the Database service [server integration](https://appwrite.io/docs/server/databases#databasesCreateCollection).
+        # @param [String] key Attribute Key.
+        # @param [] required Is attribute required?
+        # @param [String] default Default value for attribute when not provided. Cannot be set when attribute is required.
+        # @param [] array Is attribute an array?
+        #
+        # @return [AttributeIp]
+        def create_ip_attribute(database_id:, collection_id:, key:, required:, default: nil, array: nil)
+
+            path = '/databases/{databaseId}/collections/{collectionId}/attributes/ip'
+
+            params = {
+                key: key,
+                required: required,
+                default: default,
+                array: array,
+            }
+            
+            headers = {
+                "content-type": 'application/json',
+            }
+            if database_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "databaseId"')
+            end
+
+            if collection_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "collectionId"')
+            end
+
+            if key.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "key"')
+            end
+
+            if required.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "required"')
+            end
+
+                .gsub('{databaseId}', database_id)
+                .gsub('{collectionId}', collection_id)
+
+            @client.call(
+                method: 'POST',
+                path: path,
+                headers: headers,
+                params: params,
+                response_type: Models::AttributeIp
+            )
+        end
+
+        
+        # Create a string attribute.
+        # 
+        #
+        # @param [String] database_id Database ID.
+        # @param [String] collection_id Collection ID. You can create a new collection using the Database service [server integration](https://appwrite.io/docs/server/databases#databasesCreateCollection).
+        # @param [String] key Attribute Key.
+        # @param [Integer] size Attribute size for text attributes, in number of characters.
+        # @param [] required Is attribute required?
+        # @param [String] default Default value for attribute when not provided. Cannot be set when attribute is required.
+        # @param [] array Is attribute an array?
+        #
+        # @return [AttributeString]
+        def create_string_attribute(database_id:, collection_id:, key:, size:, required:, default: nil, array: nil)
+
+            path = '/databases/{databaseId}/collections/{collectionId}/attributes/string'
+
+            params = {
+                key: key,
+                size: size,
+                required: required,
+                default: default,
+                array: array,
+            }
+            
+            headers = {
+                "content-type": 'application/json',
+            }
+            if database_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "databaseId"')
+            end
+
+            if collection_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "collectionId"')
+            end
+
+            if key.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "key"')
+            end
+
+            if size.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "size"')
+            end
+
+            if required.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "required"')
+            end
+
+                .gsub('{databaseId}', database_id)
+                .gsub('{collectionId}', collection_id)
+
+            @client.call(
+                method: 'POST',
+                path: path,
+                headers: headers,
+                params: params,
+                response_type: Models::AttributeString
+            )
+        end
+
+        
+        # Create a URL attribute.
+        # 
+        #
+        # @param [String] database_id Database ID.
+        # @param [String] collection_id Collection ID. You can create a new collection using the Database service [server integration](https://appwrite.io/docs/server/databases#databasesCreateCollection).
+        # @param [String] key Attribute Key.
+        # @param [] required Is attribute required?
+        # @param [String] default Default value for attribute when not provided. Cannot be set when attribute is required.
+        # @param [] array Is attribute an array?
+        #
+        # @return [AttributeUrl]
+        def create_url_attribute(database_id:, collection_id:, key:, required:, default: nil, array: nil)
+
+            path = '/databases/{databaseId}/collections/{collectionId}/attributes/url'
+
+            params = {
+                key: key,
+                required: required,
+                default: default,
+                array: array,
+            }
+            
+            headers = {
+                "content-type": 'application/json',
+            }
+            if database_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "databaseId"')
+            end
+
+            if collection_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "collectionId"')
+            end
+
+            if key.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "key"')
+            end
+
+            if required.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "required"')
+            end
+
+                .gsub('{databaseId}', database_id)
+                .gsub('{collectionId}', collection_id)
+
+            @client.call(
+                method: 'POST',
+                path: path,
+                headers: headers,
+                params: params,
+                response_type: Models::AttributeUrl
+            )
+        end
+
+        
+        # 
+        #
+        # @param [String] database_id Database ID.
+        # @param [String] collection_id Collection ID. You can create a new collection using the Database service [server integration](https://appwrite.io/docs/server/databases#databasesCreateCollection).
+        # @param [String] key Attribute Key.
+        #
+        # @return []
+        def get_attribute(database_id:, collection_id:, key:)
+
+            path = '/databases/{databaseId}/collections/{collectionId}/attributes/{key}'
+
+            params = {
+            }
+            
+            headers = {
+                "content-type": 'application/json',
+            }
+            if database_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "databaseId"')
+            end
+
+            if collection_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "collectionId"')
+            end
+
+            if key.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "key"')
+            end
+
+                .gsub('{databaseId}', database_id)
+                .gsub('{collectionId}', collection_id)
+                .gsub('{key}', key)
+
+            @client.call(
+                method: 'GET',
+                path: path,
+                headers: headers,
+                params: params,
+            )
+        end
+
+        
+        # 
+        #
+        # @param [String] database_id Database ID.
+        # @param [String] collection_id Collection ID. You can create a new collection using the Database service [server integration](https://appwrite.io/docs/server/databases#databasesCreateCollection).
+        # @param [String] key Attribute Key.
+        #
+        # @return []
+        def delete_attribute(database_id:, collection_id:, key:)
+
+            path = '/databases/{databaseId}/collections/{collectionId}/attributes/{key}'
+
+            params = {
+            }
+            
+            headers = {
+                "content-type": 'application/json',
+            }
+            if database_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "databaseId"')
+            end
+
+            if collection_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "collectionId"')
+            end
+
+            if key.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "key"')
+            end
+
+                .gsub('{databaseId}', database_id)
+                .gsub('{collectionId}', collection_id)
+                .gsub('{key}', key)
+
+            @client.call(
+                method: 'DELETE',
+                path: path,
+                headers: headers,
+                params: params,
+            )
+        end
+
+        
+        # Get a list of all the user's documents in a given collection. You can use
+        # the query params to filter your results. On admin mode, this endpoint will
+        # return a list of all of documents belonging to the provided collectionId.
+        # [Learn more about different API modes](/docs/admin).
+        #
+        # @param [String] database_id Database ID.
+        # @param [String] collection_id Collection ID. You can create a new collection using the Database service [server integration](https://appwrite.io/docs/server/databases#databasesCreateCollection).
+        # @param [Array] queries Array of query strings generated using the Query class provided by the SDK. [Learn more about queries](https://appwrite.io/docs/databases#querying-documents). Maximum of 100 queries are allowed, each 4096 characters long.
+        #
+        # @return [DocumentList]
+        def list_documents(database_id:, collection_id:, queries: nil)
+
+            path = '/databases/{databaseId}/collections/{collectionId}/documents'
+
+            params = {
+                queries: queries,
+            }
+            
+            headers = {
+                "content-type": 'application/json',
+            }
+            if database_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "databaseId"')
+            end
+
+            if collection_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "collectionId"')
+            end
+
+                .gsub('{databaseId}', database_id)
+                .gsub('{collectionId}', collection_id)
+
+            @client.call(
+                method: 'GET',
+                path: path,
+                headers: headers,
+                params: params,
+                response_type: Models::DocumentList
+            )
+        end
+
+        
+        # Create a new Document. Before using this route, you should create a new
+        # collection resource using either a [server
+        # integration](/docs/server/databases#databasesCreateCollection) API or
+        # directly from your database console.
+        #
+        # @param [String] database_id Database ID.
+        # @param [String] collection_id Collection ID. You can create a new collection using the Database service [server integration](https://appwrite.io/docs/server/databases#databasesCreateCollection). Make sure to define attributes before creating documents.
+        # @param [String] document_id Document ID. Choose your own unique ID or pass the string "unique()" to auto generate it. 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 [Hash] data Document data as JSON object.
+        # @param [Array] permissions An array of permissions strings. By default the current user is granted with all permissions. [Learn more about permissions](/docs/permissions).
+        #
+        # @return [Document]
+        def create_document(database_id:, collection_id:, document_id:, data:, permissions: nil)
+
+            path = '/databases/{databaseId}/collections/{collectionId}/documents'
+
+            params = {
+                documentId: document_id,
+                data: data,
+                permissions: permissions,
+            }
+            
+            headers = {
+                "content-type": 'application/json',
+            }
+            if database_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "databaseId"')
+            end
+
+            if collection_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "collectionId"')
+            end
+
+            if document_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "documentId"')
+            end
+
+            if data.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "data"')
+            end
+
+                .gsub('{databaseId}', database_id)
+                .gsub('{collectionId}', collection_id)
+
+            @client.call(
+                method: 'POST',
+                path: path,
+                headers: headers,
+                params: params,
+                response_type: Models::Document
+            )
+        end
+
+        
+        # Get a document by its unique ID. This endpoint response returns a JSON
+        # object with the document data.
+        #
+        # @param [String] database_id Database ID.
+        # @param [String] collection_id Collection ID. You can create a new collection using the Database service [server integration](https://appwrite.io/docs/server/databases#databasesCreateCollection).
+        # @param [String] document_id Document ID.
+        #
+        # @return [Document]
+        def get_document(database_id:, collection_id:, document_id:)
+
+            path = '/databases/{databaseId}/collections/{collectionId}/documents/{documentId}'
+
+            params = {
+            }
+            
+            headers = {
+                "content-type": 'application/json',
+            }
+            if database_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "databaseId"')
+            end
+
+            if collection_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "collectionId"')
+            end
+
+            if document_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "documentId"')
+            end
+
+                .gsub('{databaseId}', database_id)
+                .gsub('{collectionId}', collection_id)
+                .gsub('{documentId}', document_id)
+
+            @client.call(
+                method: 'GET',
+                path: path,
+                headers: headers,
+                params: params,
+                response_type: Models::Document
+            )
+        end
+
+        
+        # Update a document by its unique ID. Using the patch method you can pass
+        # only specific fields that will get updated.
+        #
+        # @param [String] database_id Database ID.
+        # @param [String] collection_id Collection ID.
+        # @param [String] document_id Document ID.
+        # @param [Hash] data Document data as JSON object. Include only attribute and value pairs to be updated.
+        # @param [Array] permissions An array of permissions strings. By default the current permissions are inherited. [Learn more about permissions](/docs/permissions).
+        #
+        # @return [Document]
+        def update_document(database_id:, collection_id:, document_id:, data: nil, permissions: nil)
+
+            path = '/databases/{databaseId}/collections/{collectionId}/documents/{documentId}'
+
+            params = {
+                data: data,
+                permissions: permissions,
+            }
+            
+            headers = {
+                "content-type": 'application/json',
+            }
+            if database_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "databaseId"')
+            end
+
+            if collection_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "collectionId"')
+            end
+
+            if document_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "documentId"')
+            end
+
+                .gsub('{databaseId}', database_id)
+                .gsub('{collectionId}', collection_id)
+                .gsub('{documentId}', document_id)
+
+            @client.call(
+                method: 'PATCH',
+                path: path,
+                headers: headers,
+                params: params,
+                response_type: Models::Document
+            )
+        end
+
+        
+        # Delete a document by its unique ID.
+        #
+        # @param [String] database_id Database ID.
+        # @param [String] collection_id Collection ID. You can create a new collection using the Database service [server integration](https://appwrite.io/docs/server/databases#databasesCreateCollection).
+        # @param [String] document_id Document ID.
+        #
+        # @return []
+        def delete_document(database_id:, collection_id:, document_id:)
+
+            path = '/databases/{databaseId}/collections/{collectionId}/documents/{documentId}'
+
+            params = {
+            }
+            
+            headers = {
+                "content-type": 'application/json',
+            }
+            if database_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "databaseId"')
+            end
+
+            if collection_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "collectionId"')
+            end
+
+            if document_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "documentId"')
+            end
+
+                .gsub('{databaseId}', database_id)
+                .gsub('{collectionId}', collection_id)
+                .gsub('{documentId}', document_id)
+
+            @client.call(
+                method: 'DELETE',
+                path: path,
+                headers: headers,
+                params: params,
+            )
+        end
+
+        
+        # 
+        #
+        # @param [String] database_id Database ID.
+        # @param [String] collection_id Collection ID. You can create a new collection using the Database service [server integration](https://appwrite.io/docs/server/databases#databasesCreateCollection).
+        #
+        # @return [IndexList]
+        def list_indexes(database_id:, collection_id:)
+
+            path = '/databases/{databaseId}/collections/{collectionId}/indexes'
+
+            params = {
+            }
+            
+            headers = {
+                "content-type": 'application/json',
+            }
+            if database_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "databaseId"')
+            end
+
+            if collection_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "collectionId"')
+            end
+
+                .gsub('{databaseId}', database_id)
+                .gsub('{collectionId}', collection_id)
+
+            @client.call(
+                method: 'GET',
+                path: path,
+                headers: headers,
+                params: params,
+                response_type: Models::IndexList
+            )
+        end
+
+        
+        # 
+        #
+        # @param [String] database_id Database ID.
+        # @param [String] collection_id Collection ID. You can create a new collection using the Database service [server integration](https://appwrite.io/docs/server/databases#databasesCreateCollection).
+        # @param [String] key Index Key.
+        # @param [String] type Index type.
+        # @param [Array] attributes Array of attributes to index. Maximum of 100 attributes are allowed, each 32 characters long.
+        # @param [Array] orders Array of index orders. Maximum of 100 orders are allowed.
+        #
+        # @return [Index]
+        def create_index(database_id:, collection_id:, key:, type:, attributes:, orders: nil)
+
+            path = '/databases/{databaseId}/collections/{collectionId}/indexes'
+
+            params = {
+                key: key,
+                type: type,
+                attributes: attributes,
+                orders: orders,
+            }
+            
+            headers = {
+                "content-type": 'application/json',
+            }
+            if database_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "databaseId"')
+            end
+
+            if collection_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "collectionId"')
+            end
+
+            if key.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "key"')
+            end
+
+            if type.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "type"')
+            end
+
+            if attributes.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "attributes"')
+            end
+
+                .gsub('{databaseId}', database_id)
+                .gsub('{collectionId}', collection_id)
+
+            @client.call(
+                method: 'POST',
+                path: path,
+                headers: headers,
+                params: params,
+                response_type: Models::Index
+            )
+        end
+
+        
+        # 
+        #
+        # @param [String] database_id Database ID.
+        # @param [String] collection_id Collection ID. You can create a new collection using the Database service [server integration](https://appwrite.io/docs/server/databases#databasesCreateCollection).
+        # @param [String] key Index Key.
+        #
+        # @return [Index]
+        def get_index(database_id:, collection_id:, key:)
+
+            path = '/databases/{databaseId}/collections/{collectionId}/indexes/{key}'
+
+            params = {
+            }
+            
+            headers = {
+                "content-type": 'application/json',
+            }
+            if database_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "databaseId"')
+            end
+
+            if collection_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "collectionId"')
+            end
+
+            if key.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "key"')
+            end
+
+                .gsub('{databaseId}', database_id)
+                .gsub('{collectionId}', collection_id)
+                .gsub('{key}', key)
+
+            @client.call(
+                method: 'GET',
+                path: path,
+                headers: headers,
+                params: params,
+                response_type: Models::Index
+            )
+        end
+
+        
+        # 
+        #
+        # @param [String] database_id Database ID.
+        # @param [String] collection_id Collection ID. You can create a new collection using the Database service [server integration](https://appwrite.io/docs/server/databases#databasesCreateCollection).
+        # @param [String] key Index Key.
+        #
+        # @return []
+        def delete_index(database_id:, collection_id:, key:)
+
+            path = '/databases/{databaseId}/collections/{collectionId}/indexes/{key}'
+
+            params = {
+            }
+            
+            headers = {
+                "content-type": 'application/json',
+            }
+            if database_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "databaseId"')
+            end
+
+            if collection_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "collectionId"')
+            end
+
+            if key.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "key"')
+            end
+
+                .gsub('{databaseId}', database_id)
+                .gsub('{collectionId}', collection_id)
+                .gsub('{key}', key)
+
+            @client.call(
+                method: 'DELETE',
+                path: path,
+                headers: headers,
+                params: params,
+            )
+        end
+
+        
+    end 
+end