using System.Numerics;
using Managing.ABI.GmxV2.DataStore.ContractDefinition;
using Nethereum.RPC.Eth.DTOs;
using Nethereum.Web3;

namespace Managing.ABI.GmxV2.DataStore
{
    public partial class DataStoreService: ContractWeb3ServiceBase
    {
        public static Task<TransactionReceipt> DeployContractAndWaitForReceiptAsync(Nethereum.Web3.IWeb3 web3, DataStoreDeployment dataStoreDeployment, CancellationTokenSource cancellationTokenSource = null)
        {
            return web3.Eth.GetContractDeploymentHandler<DataStoreDeployment>().SendRequestAndWaitForReceiptAsync(dataStoreDeployment, cancellationTokenSource);
        }

        public static Task<string> DeployContractAsync(Nethereum.Web3.IWeb3 web3, DataStoreDeployment dataStoreDeployment)
        {
            return web3.Eth.GetContractDeploymentHandler<DataStoreDeployment>().SendRequestAsync(dataStoreDeployment);
        }

        public static async Task<DataStoreService> DeployContractAndGetServiceAsync(Nethereum.Web3.IWeb3 web3, DataStoreDeployment dataStoreDeployment, CancellationTokenSource cancellationTokenSource = null)
        {
            var receipt = await DeployContractAndWaitForReceiptAsync(web3, dataStoreDeployment, cancellationTokenSource);
            return new DataStoreService(web3, receipt.ContractAddress);
        }

        public DataStoreService(Nethereum.Web3.IWeb3 web3, string contractAddress) : base(web3, contractAddress)
        {
        }

        public Task<string> AddAddressRequestAsync(AddAddressFunction addAddressFunction)
        {
             return ContractHandler.SendRequestAsync(addAddressFunction);
        }

        public Task<TransactionReceipt> AddAddressRequestAndWaitForReceiptAsync(AddAddressFunction addAddressFunction, CancellationTokenSource cancellationToken = null)
        {
             return ContractHandler.SendRequestAndWaitForReceiptAsync(addAddressFunction, cancellationToken);
        }

        public Task<string> AddAddressRequestAsync(byte[] setKey, string value)
        {
            var addAddressFunction = new AddAddressFunction();
                addAddressFunction.SetKey = setKey;
                addAddressFunction.Value = value;
            
             return ContractHandler.SendRequestAsync(addAddressFunction);
        }

        public Task<TransactionReceipt> AddAddressRequestAndWaitForReceiptAsync(byte[] setKey, string value, CancellationTokenSource cancellationToken = null)
        {
            var addAddressFunction = new AddAddressFunction();
                addAddressFunction.SetKey = setKey;
                addAddressFunction.Value = value;
            
             return ContractHandler.SendRequestAndWaitForReceiptAsync(addAddressFunction, cancellationToken);
        }

        public Task<string> AddBytes32RequestAsync(AddBytes32Function addBytes32Function)
        {
             return ContractHandler.SendRequestAsync(addBytes32Function);
        }

        public Task<TransactionReceipt> AddBytes32RequestAndWaitForReceiptAsync(AddBytes32Function addBytes32Function, CancellationTokenSource cancellationToken = null)
        {
             return ContractHandler.SendRequestAndWaitForReceiptAsync(addBytes32Function, cancellationToken);
        }

        public Task<string> AddBytes32RequestAsync(byte[] setKey, byte[] value)
        {
            var addBytes32Function = new AddBytes32Function();
                addBytes32Function.SetKey = setKey;
                addBytes32Function.Value = value;
            
             return ContractHandler.SendRequestAsync(addBytes32Function);
        }

        public Task<TransactionReceipt> AddBytes32RequestAndWaitForReceiptAsync(byte[] setKey, byte[] value, CancellationTokenSource cancellationToken = null)
        {
            var addBytes32Function = new AddBytes32Function();
                addBytes32Function.SetKey = setKey;
                addBytes32Function.Value = value;
            
             return ContractHandler.SendRequestAndWaitForReceiptAsync(addBytes32Function, cancellationToken);
        }

        public Task<string> AddUintRequestAsync(AddUintFunction addUintFunction)
        {
             return ContractHandler.SendRequestAsync(addUintFunction);
        }

        public Task<TransactionReceipt> AddUintRequestAndWaitForReceiptAsync(AddUintFunction addUintFunction, CancellationTokenSource cancellationToken = null)
        {
             return ContractHandler.SendRequestAndWaitForReceiptAsync(addUintFunction, cancellationToken);
        }

        public Task<string> AddUintRequestAsync(byte[] setKey, BigInteger value)
        {
            var addUintFunction = new AddUintFunction();
                addUintFunction.SetKey = setKey;
                addUintFunction.Value = value;
            
             return ContractHandler.SendRequestAsync(addUintFunction);
        }

        public Task<TransactionReceipt> AddUintRequestAndWaitForReceiptAsync(byte[] setKey, BigInteger value, CancellationTokenSource cancellationToken = null)
        {
            var addUintFunction = new AddUintFunction();
                addUintFunction.SetKey = setKey;
                addUintFunction.Value = value;
            
             return ContractHandler.SendRequestAndWaitForReceiptAsync(addUintFunction, cancellationToken);
        }

        public Task<string> AddressArrayValuesQueryAsync(AddressArrayValuesFunction addressArrayValuesFunction, BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<AddressArrayValuesFunction, string>(addressArrayValuesFunction, blockParameter);
        }

        
        public Task<string> AddressArrayValuesQueryAsync(byte[] returnValue1, BigInteger returnValue2, BlockParameter blockParameter = null)
        {
            var addressArrayValuesFunction = new AddressArrayValuesFunction();
                addressArrayValuesFunction.ReturnValue1 = returnValue1;
                addressArrayValuesFunction.ReturnValue2 = returnValue2;
            
            return ContractHandler.QueryAsync<AddressArrayValuesFunction, string>(addressArrayValuesFunction, blockParameter);
        }

        public Task<string> AddressValuesQueryAsync(AddressValuesFunction addressValuesFunction, BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<AddressValuesFunction, string>(addressValuesFunction, blockParameter);
        }

        
        public Task<string> AddressValuesQueryAsync(byte[] returnValue1, BlockParameter blockParameter = null)
        {
            var addressValuesFunction = new AddressValuesFunction();
                addressValuesFunction.ReturnValue1 = returnValue1;
            
            return ContractHandler.QueryAsync<AddressValuesFunction, string>(addressValuesFunction, blockParameter);
        }

        public Task<string> ApplyBoundedDeltaToUintRequestAsync(ApplyBoundedDeltaToUintFunction applyBoundedDeltaToUintFunction)
        {
             return ContractHandler.SendRequestAsync(applyBoundedDeltaToUintFunction);
        }

        public Task<TransactionReceipt> ApplyBoundedDeltaToUintRequestAndWaitForReceiptAsync(ApplyBoundedDeltaToUintFunction applyBoundedDeltaToUintFunction, CancellationTokenSource cancellationToken = null)
        {
             return ContractHandler.SendRequestAndWaitForReceiptAsync(applyBoundedDeltaToUintFunction, cancellationToken);
        }

        public Task<string> ApplyBoundedDeltaToUintRequestAsync(byte[] key, BigInteger value)
        {
            var applyBoundedDeltaToUintFunction = new ApplyBoundedDeltaToUintFunction();
                applyBoundedDeltaToUintFunction.Key = key;
                applyBoundedDeltaToUintFunction.Value = value;
            
             return ContractHandler.SendRequestAsync(applyBoundedDeltaToUintFunction);
        }

        public Task<TransactionReceipt> ApplyBoundedDeltaToUintRequestAndWaitForReceiptAsync(byte[] key, BigInteger value, CancellationTokenSource cancellationToken = null)
        {
            var applyBoundedDeltaToUintFunction = new ApplyBoundedDeltaToUintFunction();
                applyBoundedDeltaToUintFunction.Key = key;
                applyBoundedDeltaToUintFunction.Value = value;
            
             return ContractHandler.SendRequestAndWaitForReceiptAsync(applyBoundedDeltaToUintFunction, cancellationToken);
        }

        public Task<string> ApplyDeltaToIntRequestAsync(ApplyDeltaToIntFunction applyDeltaToIntFunction)
        {
             return ContractHandler.SendRequestAsync(applyDeltaToIntFunction);
        }

        public Task<TransactionReceipt> ApplyDeltaToIntRequestAndWaitForReceiptAsync(ApplyDeltaToIntFunction applyDeltaToIntFunction, CancellationTokenSource cancellationToken = null)
        {
             return ContractHandler.SendRequestAndWaitForReceiptAsync(applyDeltaToIntFunction, cancellationToken);
        }

        public Task<string> ApplyDeltaToIntRequestAsync(byte[] key, BigInteger value)
        {
            var applyDeltaToIntFunction = new ApplyDeltaToIntFunction();
                applyDeltaToIntFunction.Key = key;
                applyDeltaToIntFunction.Value = value;
            
             return ContractHandler.SendRequestAsync(applyDeltaToIntFunction);
        }

        public Task<TransactionReceipt> ApplyDeltaToIntRequestAndWaitForReceiptAsync(byte[] key, BigInteger value, CancellationTokenSource cancellationToken = null)
        {
            var applyDeltaToIntFunction = new ApplyDeltaToIntFunction();
                applyDeltaToIntFunction.Key = key;
                applyDeltaToIntFunction.Value = value;
            
             return ContractHandler.SendRequestAndWaitForReceiptAsync(applyDeltaToIntFunction, cancellationToken);
        }

        public Task<string> ApplyDeltaToUintRequestAsync(ApplyDeltaToUint1Function applyDeltaToUint1Function)
        {
             return ContractHandler.SendRequestAsync(applyDeltaToUint1Function);
        }

        public Task<TransactionReceipt> ApplyDeltaToUintRequestAndWaitForReceiptAsync(ApplyDeltaToUint1Function applyDeltaToUint1Function, CancellationTokenSource cancellationToken = null)
        {
             return ContractHandler.SendRequestAndWaitForReceiptAsync(applyDeltaToUint1Function, cancellationToken);
        }

        public Task<string> ApplyDeltaToUintRequestAsync(byte[] key, BigInteger value, string errorMessage)
        {
            var applyDeltaToUint1Function = new ApplyDeltaToUint1Function();
                applyDeltaToUint1Function.Key = key;
                applyDeltaToUint1Function.Value = value;
                applyDeltaToUint1Function.ErrorMessage = errorMessage;
            
             return ContractHandler.SendRequestAsync(applyDeltaToUint1Function);
        }

        public Task<TransactionReceipt> ApplyDeltaToUintRequestAndWaitForReceiptAsync(byte[] key, BigInteger value, string errorMessage, CancellationTokenSource cancellationToken = null)
        {
            var applyDeltaToUint1Function = new ApplyDeltaToUint1Function();
                applyDeltaToUint1Function.Key = key;
                applyDeltaToUint1Function.Value = value;
                applyDeltaToUint1Function.ErrorMessage = errorMessage;
            
             return ContractHandler.SendRequestAndWaitForReceiptAsync(applyDeltaToUint1Function, cancellationToken);
        }

        public Task<string> ApplyDeltaToUintRequestAsync(ApplyDeltaToUintFunction applyDeltaToUintFunction)
        {
             return ContractHandler.SendRequestAsync(applyDeltaToUintFunction);
        }

        public Task<TransactionReceipt> ApplyDeltaToUintRequestAndWaitForReceiptAsync(ApplyDeltaToUintFunction applyDeltaToUintFunction, CancellationTokenSource cancellationToken = null)
        {
             return ContractHandler.SendRequestAndWaitForReceiptAsync(applyDeltaToUintFunction, cancellationToken);
        }

        public Task<string> ApplyDeltaToUintRequestAsync(byte[] key, BigInteger value)
        {
            var applyDeltaToUintFunction = new ApplyDeltaToUintFunction();
                applyDeltaToUintFunction.Key = key;
                applyDeltaToUintFunction.Value = value;
            
             return ContractHandler.SendRequestAsync(applyDeltaToUintFunction);
        }

        public Task<TransactionReceipt> ApplyDeltaToUintRequestAndWaitForReceiptAsync(byte[] key, BigInteger value, CancellationTokenSource cancellationToken = null)
        {
            var applyDeltaToUintFunction = new ApplyDeltaToUintFunction();
                applyDeltaToUintFunction.Key = key;
                applyDeltaToUintFunction.Value = value;
            
             return ContractHandler.SendRequestAndWaitForReceiptAsync(applyDeltaToUintFunction, cancellationToken);
        }

        public Task<bool> BoolArrayValuesQueryAsync(BoolArrayValuesFunction boolArrayValuesFunction, BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<BoolArrayValuesFunction, bool>(boolArrayValuesFunction, blockParameter);
        }

        
        public Task<bool> BoolArrayValuesQueryAsync(byte[] returnValue1, BigInteger returnValue2, BlockParameter blockParameter = null)
        {
            var boolArrayValuesFunction = new BoolArrayValuesFunction();
                boolArrayValuesFunction.ReturnValue1 = returnValue1;
                boolArrayValuesFunction.ReturnValue2 = returnValue2;
            
            return ContractHandler.QueryAsync<BoolArrayValuesFunction, bool>(boolArrayValuesFunction, blockParameter);
        }

        public Task<bool> BoolValuesQueryAsync(BoolValuesFunction boolValuesFunction, BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<BoolValuesFunction, bool>(boolValuesFunction, blockParameter);
        }

        
        public Task<bool> BoolValuesQueryAsync(byte[] returnValue1, BlockParameter blockParameter = null)
        {
            var boolValuesFunction = new BoolValuesFunction();
                boolValuesFunction.ReturnValue1 = returnValue1;
            
            return ContractHandler.QueryAsync<BoolValuesFunction, bool>(boolValuesFunction, blockParameter);
        }

        public Task<byte[]> Bytes32ArrayValuesQueryAsync(Bytes32ArrayValuesFunction bytes32ArrayValuesFunction, BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<Bytes32ArrayValuesFunction, byte[]>(bytes32ArrayValuesFunction, blockParameter);
        }

        
        public Task<byte[]> Bytes32ArrayValuesQueryAsync(byte[] returnValue1, BigInteger returnValue2, BlockParameter blockParameter = null)
        {
            var bytes32ArrayValuesFunction = new Bytes32ArrayValuesFunction();
                bytes32ArrayValuesFunction.ReturnValue1 = returnValue1;
                bytes32ArrayValuesFunction.ReturnValue2 = returnValue2;
            
            return ContractHandler.QueryAsync<Bytes32ArrayValuesFunction, byte[]>(bytes32ArrayValuesFunction, blockParameter);
        }

        public Task<byte[]> Bytes32ValuesQueryAsync(Bytes32ValuesFunction bytes32ValuesFunction, BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<Bytes32ValuesFunction, byte[]>(bytes32ValuesFunction, blockParameter);
        }

        
        public Task<byte[]> Bytes32ValuesQueryAsync(byte[] returnValue1, BlockParameter blockParameter = null)
        {
            var bytes32ValuesFunction = new Bytes32ValuesFunction();
                bytes32ValuesFunction.ReturnValue1 = returnValue1;
            
            return ContractHandler.QueryAsync<Bytes32ValuesFunction, byte[]>(bytes32ValuesFunction, blockParameter);
        }

        public Task<bool> ContainsAddressQueryAsync(ContainsAddressFunction containsAddressFunction, BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<ContainsAddressFunction, bool>(containsAddressFunction, blockParameter);
        }

        
        public Task<bool> ContainsAddressQueryAsync(byte[] setKey, string value, BlockParameter blockParameter = null)
        {
            var containsAddressFunction = new ContainsAddressFunction();
                containsAddressFunction.SetKey = setKey;
                containsAddressFunction.Value = value;
            
            return ContractHandler.QueryAsync<ContainsAddressFunction, bool>(containsAddressFunction, blockParameter);
        }

        public Task<bool> ContainsBytes32QueryAsync(ContainsBytes32Function containsBytes32Function, BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<ContainsBytes32Function, bool>(containsBytes32Function, blockParameter);
        }

        
        public Task<bool> ContainsBytes32QueryAsync(byte[] setKey, byte[] value, BlockParameter blockParameter = null)
        {
            var containsBytes32Function = new ContainsBytes32Function();
                containsBytes32Function.SetKey = setKey;
                containsBytes32Function.Value = value;
            
            return ContractHandler.QueryAsync<ContainsBytes32Function, bool>(containsBytes32Function, blockParameter);
        }

        public Task<bool> ContainsUintQueryAsync(ContainsUintFunction containsUintFunction, BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<ContainsUintFunction, bool>(containsUintFunction, blockParameter);
        }

        
        public Task<bool> ContainsUintQueryAsync(byte[] setKey, BigInteger value, BlockParameter blockParameter = null)
        {
            var containsUintFunction = new ContainsUintFunction();
                containsUintFunction.SetKey = setKey;
                containsUintFunction.Value = value;
            
            return ContractHandler.QueryAsync<ContainsUintFunction, bool>(containsUintFunction, blockParameter);
        }

        public Task<string> DecrementIntRequestAsync(DecrementIntFunction decrementIntFunction)
        {
             return ContractHandler.SendRequestAsync(decrementIntFunction);
        }

        public Task<TransactionReceipt> DecrementIntRequestAndWaitForReceiptAsync(DecrementIntFunction decrementIntFunction, CancellationTokenSource cancellationToken = null)
        {
             return ContractHandler.SendRequestAndWaitForReceiptAsync(decrementIntFunction, cancellationToken);
        }

        public Task<string> DecrementIntRequestAsync(byte[] key, BigInteger value)
        {
            var decrementIntFunction = new DecrementIntFunction();
                decrementIntFunction.Key = key;
                decrementIntFunction.Value = value;
            
             return ContractHandler.SendRequestAsync(decrementIntFunction);
        }

        public Task<TransactionReceipt> DecrementIntRequestAndWaitForReceiptAsync(byte[] key, BigInteger value, CancellationTokenSource cancellationToken = null)
        {
            var decrementIntFunction = new DecrementIntFunction();
                decrementIntFunction.Key = key;
                decrementIntFunction.Value = value;
            
             return ContractHandler.SendRequestAndWaitForReceiptAsync(decrementIntFunction, cancellationToken);
        }

        public Task<string> DecrementUintRequestAsync(DecrementUintFunction decrementUintFunction)
        {
             return ContractHandler.SendRequestAsync(decrementUintFunction);
        }

        public Task<TransactionReceipt> DecrementUintRequestAndWaitForReceiptAsync(DecrementUintFunction decrementUintFunction, CancellationTokenSource cancellationToken = null)
        {
             return ContractHandler.SendRequestAndWaitForReceiptAsync(decrementUintFunction, cancellationToken);
        }

        public Task<string> DecrementUintRequestAsync(byte[] key, BigInteger value)
        {
            var decrementUintFunction = new DecrementUintFunction();
                decrementUintFunction.Key = key;
                decrementUintFunction.Value = value;
            
             return ContractHandler.SendRequestAsync(decrementUintFunction);
        }

        public Task<TransactionReceipt> DecrementUintRequestAndWaitForReceiptAsync(byte[] key, BigInteger value, CancellationTokenSource cancellationToken = null)
        {
            var decrementUintFunction = new DecrementUintFunction();
                decrementUintFunction.Key = key;
                decrementUintFunction.Value = value;
            
             return ContractHandler.SendRequestAndWaitForReceiptAsync(decrementUintFunction, cancellationToken);
        }

        public Task<string> GetAddressQueryAsync(GetAddressFunction getAddressFunction, BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<GetAddressFunction, string>(getAddressFunction, blockParameter);
        }

        
        public Task<string> GetAddressQueryAsync(byte[] key, BlockParameter blockParameter = null)
        {
            var getAddressFunction = new GetAddressFunction();
                getAddressFunction.Key = key;
            
            return ContractHandler.QueryAsync<GetAddressFunction, string>(getAddressFunction, blockParameter);
        }

        public Task<List<string>> GetAddressArrayQueryAsync(GetAddressArrayFunction getAddressArrayFunction, BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<GetAddressArrayFunction, List<string>>(getAddressArrayFunction, blockParameter);
        }

        
        public Task<List<string>> GetAddressArrayQueryAsync(byte[] key, BlockParameter blockParameter = null)
        {
            var getAddressArrayFunction = new GetAddressArrayFunction();
                getAddressArrayFunction.Key = key;
            
            return ContractHandler.QueryAsync<GetAddressArrayFunction, List<string>>(getAddressArrayFunction, blockParameter);
        }

        public Task<BigInteger> GetAddressCountQueryAsync(GetAddressCountFunction getAddressCountFunction, BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<GetAddressCountFunction, BigInteger>(getAddressCountFunction, blockParameter);
        }

        
        public Task<BigInteger> GetAddressCountQueryAsync(byte[] setKey, BlockParameter blockParameter = null)
        {
            var getAddressCountFunction = new GetAddressCountFunction();
                getAddressCountFunction.SetKey = setKey;
            
            return ContractHandler.QueryAsync<GetAddressCountFunction, BigInteger>(getAddressCountFunction, blockParameter);
        }

        public Task<List<string>> GetAddressValuesAtQueryAsync(GetAddressValuesAtFunction getAddressValuesAtFunction, BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<GetAddressValuesAtFunction, List<string>>(getAddressValuesAtFunction, blockParameter);
        }

        
        public Task<List<string>> GetAddressValuesAtQueryAsync(byte[] setKey, BigInteger start, BigInteger end, BlockParameter blockParameter = null)
        {
            var getAddressValuesAtFunction = new GetAddressValuesAtFunction();
                getAddressValuesAtFunction.SetKey = setKey;
                getAddressValuesAtFunction.Start = start;
                getAddressValuesAtFunction.End = end;
            
            return ContractHandler.QueryAsync<GetAddressValuesAtFunction, List<string>>(getAddressValuesAtFunction, blockParameter);
        }

        public Task<bool> GetBoolQueryAsync(GetBoolFunction getBoolFunction, BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<GetBoolFunction, bool>(getBoolFunction, blockParameter);
        }

        
        public Task<bool> GetBoolQueryAsync(byte[] key, BlockParameter blockParameter = null)
        {
            var getBoolFunction = new GetBoolFunction();
                getBoolFunction.Key = key;
            
            return ContractHandler.QueryAsync<GetBoolFunction, bool>(getBoolFunction, blockParameter);
        }

        public Task<List<bool>> GetBoolArrayQueryAsync(GetBoolArrayFunction getBoolArrayFunction, BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<GetBoolArrayFunction, List<bool>>(getBoolArrayFunction, blockParameter);
        }

        
        public Task<List<bool>> GetBoolArrayQueryAsync(byte[] key, BlockParameter blockParameter = null)
        {
            var getBoolArrayFunction = new GetBoolArrayFunction();
                getBoolArrayFunction.Key = key;
            
            return ContractHandler.QueryAsync<GetBoolArrayFunction, List<bool>>(getBoolArrayFunction, blockParameter);
        }

        public Task<byte[]> GetBytes32QueryAsync(GetBytes32Function getBytes32Function, BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<GetBytes32Function, byte[]>(getBytes32Function, blockParameter);
        }

        
        public Task<byte[]> GetBytes32QueryAsync(byte[] key, BlockParameter blockParameter = null)
        {
            var getBytes32Function = new GetBytes32Function();
                getBytes32Function.Key = key;
            
            return ContractHandler.QueryAsync<GetBytes32Function, byte[]>(getBytes32Function, blockParameter);
        }

        public Task<List<byte[]>> GetBytes32ArrayQueryAsync(GetBytes32ArrayFunction getBytes32ArrayFunction, BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<GetBytes32ArrayFunction, List<byte[]>>(getBytes32ArrayFunction, blockParameter);
        }

        
        public Task<List<byte[]>> GetBytes32ArrayQueryAsync(byte[] key, BlockParameter blockParameter = null)
        {
            var getBytes32ArrayFunction = new GetBytes32ArrayFunction();
                getBytes32ArrayFunction.Key = key;
            
            return ContractHandler.QueryAsync<GetBytes32ArrayFunction, List<byte[]>>(getBytes32ArrayFunction, blockParameter);
        }

        public Task<BigInteger> GetBytes32CountQueryAsync(GetBytes32CountFunction getBytes32CountFunction, BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<GetBytes32CountFunction, BigInteger>(getBytes32CountFunction, blockParameter);
        }

        
        public Task<BigInteger> GetBytes32CountQueryAsync(byte[] setKey, BlockParameter blockParameter = null)
        {
            var getBytes32CountFunction = new GetBytes32CountFunction();
                getBytes32CountFunction.SetKey = setKey;
            
            return ContractHandler.QueryAsync<GetBytes32CountFunction, BigInteger>(getBytes32CountFunction, blockParameter);
        }

        public Task<List<byte[]>> GetBytes32ValuesAtQueryAsync(GetBytes32ValuesAtFunction getBytes32ValuesAtFunction, BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<GetBytes32ValuesAtFunction, List<byte[]>>(getBytes32ValuesAtFunction, blockParameter);
        }

        
        public Task<List<byte[]>> GetBytes32ValuesAtQueryAsync(byte[] setKey, BigInteger start, BigInteger end, BlockParameter blockParameter = null)
        {
            var getBytes32ValuesAtFunction = new GetBytes32ValuesAtFunction();
                getBytes32ValuesAtFunction.SetKey = setKey;
                getBytes32ValuesAtFunction.Start = start;
                getBytes32ValuesAtFunction.End = end;
            
            return ContractHandler.QueryAsync<GetBytes32ValuesAtFunction, List<byte[]>>(getBytes32ValuesAtFunction, blockParameter);
        }

        public Task<BigInteger> GetIntQueryAsync(GetIntFunction getIntFunction, BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<GetIntFunction, BigInteger>(getIntFunction, blockParameter);
        }

        
        public Task<BigInteger> GetIntQueryAsync(byte[] key, BlockParameter blockParameter = null)
        {
            var getIntFunction = new GetIntFunction();
                getIntFunction.Key = key;
            
            return ContractHandler.QueryAsync<GetIntFunction, BigInteger>(getIntFunction, blockParameter);
        }

        public Task<List<BigInteger>> GetIntArrayQueryAsync(GetIntArrayFunction getIntArrayFunction, BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<GetIntArrayFunction, List<BigInteger>>(getIntArrayFunction, blockParameter);
        }

        
        public Task<List<BigInteger>> GetIntArrayQueryAsync(byte[] key, BlockParameter blockParameter = null)
        {
            var getIntArrayFunction = new GetIntArrayFunction();
                getIntArrayFunction.Key = key;
            
            return ContractHandler.QueryAsync<GetIntArrayFunction, List<BigInteger>>(getIntArrayFunction, blockParameter);
        }

        public Task<string> GetStringQueryAsync(GetStringFunction getStringFunction, BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<GetStringFunction, string>(getStringFunction, blockParameter);
        }

        
        public Task<string> GetStringQueryAsync(byte[] key, BlockParameter blockParameter = null)
        {
            var getStringFunction = new GetStringFunction();
                getStringFunction.Key = key;
            
            return ContractHandler.QueryAsync<GetStringFunction, string>(getStringFunction, blockParameter);
        }

        public Task<List<string>> GetStringArrayQueryAsync(GetStringArrayFunction getStringArrayFunction, BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<GetStringArrayFunction, List<string>>(getStringArrayFunction, blockParameter);
        }

        
        public Task<List<string>> GetStringArrayQueryAsync(byte[] key, BlockParameter blockParameter = null)
        {
            var getStringArrayFunction = new GetStringArrayFunction();
                getStringArrayFunction.Key = key;
            
            return ContractHandler.QueryAsync<GetStringArrayFunction, List<string>>(getStringArrayFunction, blockParameter);
        }

        public Task<BigInteger> GetUintQueryAsync(GetUintFunction getUintFunction, BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<GetUintFunction, BigInteger>(getUintFunction, blockParameter);
        }

        
        public Task<BigInteger> GetUintQueryAsync(byte[] key, BlockParameter blockParameter = null)
        {
            var getUintFunction = new GetUintFunction();
                getUintFunction.Key = key;
            
            return ContractHandler.QueryAsync<GetUintFunction, BigInteger>(getUintFunction, blockParameter);
        }

        public Task<List<BigInteger>> GetUintArrayQueryAsync(GetUintArrayFunction getUintArrayFunction, BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<GetUintArrayFunction, List<BigInteger>>(getUintArrayFunction, blockParameter);
        }

        
        public Task<List<BigInteger>> GetUintArrayQueryAsync(byte[] key, BlockParameter blockParameter = null)
        {
            var getUintArrayFunction = new GetUintArrayFunction();
                getUintArrayFunction.Key = key;
            
            return ContractHandler.QueryAsync<GetUintArrayFunction, List<BigInteger>>(getUintArrayFunction, blockParameter);
        }

        public Task<BigInteger> GetUintCountQueryAsync(GetUintCountFunction getUintCountFunction, BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<GetUintCountFunction, BigInteger>(getUintCountFunction, blockParameter);
        }

        
        public Task<BigInteger> GetUintCountQueryAsync(byte[] setKey, BlockParameter blockParameter = null)
        {
            var getUintCountFunction = new GetUintCountFunction();
                getUintCountFunction.SetKey = setKey;
            
            return ContractHandler.QueryAsync<GetUintCountFunction, BigInteger>(getUintCountFunction, blockParameter);
        }

        public Task<List<BigInteger>> GetUintValuesAtQueryAsync(GetUintValuesAtFunction getUintValuesAtFunction, BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<GetUintValuesAtFunction, List<BigInteger>>(getUintValuesAtFunction, blockParameter);
        }

        
        public Task<List<BigInteger>> GetUintValuesAtQueryAsync(byte[] setKey, BigInteger start, BigInteger end, BlockParameter blockParameter = null)
        {
            var getUintValuesAtFunction = new GetUintValuesAtFunction();
                getUintValuesAtFunction.SetKey = setKey;
                getUintValuesAtFunction.Start = start;
                getUintValuesAtFunction.End = end;
            
            return ContractHandler.QueryAsync<GetUintValuesAtFunction, List<BigInteger>>(getUintValuesAtFunction, blockParameter);
        }

        public Task<string> IncrementIntRequestAsync(IncrementIntFunction incrementIntFunction)
        {
             return ContractHandler.SendRequestAsync(incrementIntFunction);
        }

        public Task<TransactionReceipt> IncrementIntRequestAndWaitForReceiptAsync(IncrementIntFunction incrementIntFunction, CancellationTokenSource cancellationToken = null)
        {
             return ContractHandler.SendRequestAndWaitForReceiptAsync(incrementIntFunction, cancellationToken);
        }

        public Task<string> IncrementIntRequestAsync(byte[] key, BigInteger value)
        {
            var incrementIntFunction = new IncrementIntFunction();
                incrementIntFunction.Key = key;
                incrementIntFunction.Value = value;
            
             return ContractHandler.SendRequestAsync(incrementIntFunction);
        }

        public Task<TransactionReceipt> IncrementIntRequestAndWaitForReceiptAsync(byte[] key, BigInteger value, CancellationTokenSource cancellationToken = null)
        {
            var incrementIntFunction = new IncrementIntFunction();
                incrementIntFunction.Key = key;
                incrementIntFunction.Value = value;
            
             return ContractHandler.SendRequestAndWaitForReceiptAsync(incrementIntFunction, cancellationToken);
        }

        public Task<string> IncrementUintRequestAsync(IncrementUintFunction incrementUintFunction)
        {
             return ContractHandler.SendRequestAsync(incrementUintFunction);
        }

        public Task<TransactionReceipt> IncrementUintRequestAndWaitForReceiptAsync(IncrementUintFunction incrementUintFunction, CancellationTokenSource cancellationToken = null)
        {
             return ContractHandler.SendRequestAndWaitForReceiptAsync(incrementUintFunction, cancellationToken);
        }

        public Task<string> IncrementUintRequestAsync(byte[] key, BigInteger value)
        {
            var incrementUintFunction = new IncrementUintFunction();
                incrementUintFunction.Key = key;
                incrementUintFunction.Value = value;
            
             return ContractHandler.SendRequestAsync(incrementUintFunction);
        }

        public Task<TransactionReceipt> IncrementUintRequestAndWaitForReceiptAsync(byte[] key, BigInteger value, CancellationTokenSource cancellationToken = null)
        {
            var incrementUintFunction = new IncrementUintFunction();
                incrementUintFunction.Key = key;
                incrementUintFunction.Value = value;
            
             return ContractHandler.SendRequestAndWaitForReceiptAsync(incrementUintFunction, cancellationToken);
        }

        public Task<BigInteger> IntArrayValuesQueryAsync(IntArrayValuesFunction intArrayValuesFunction, BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<IntArrayValuesFunction, BigInteger>(intArrayValuesFunction, blockParameter);
        }

        
        public Task<BigInteger> IntArrayValuesQueryAsync(byte[] returnValue1, BigInteger returnValue2, BlockParameter blockParameter = null)
        {
            var intArrayValuesFunction = new IntArrayValuesFunction();
                intArrayValuesFunction.ReturnValue1 = returnValue1;
                intArrayValuesFunction.ReturnValue2 = returnValue2;
            
            return ContractHandler.QueryAsync<IntArrayValuesFunction, BigInteger>(intArrayValuesFunction, blockParameter);
        }

        public Task<BigInteger> IntValuesQueryAsync(IntValuesFunction intValuesFunction, BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<IntValuesFunction, BigInteger>(intValuesFunction, blockParameter);
        }

        
        public Task<BigInteger> IntValuesQueryAsync(byte[] returnValue1, BlockParameter blockParameter = null)
        {
            var intValuesFunction = new IntValuesFunction();
                intValuesFunction.ReturnValue1 = returnValue1;
            
            return ContractHandler.QueryAsync<IntValuesFunction, BigInteger>(intValuesFunction, blockParameter);
        }

        public Task<string> RemoveAddressRequestAsync(RemoveAddress1Function removeAddress1Function)
        {
             return ContractHandler.SendRequestAsync(removeAddress1Function);
        }

        public Task<TransactionReceipt> RemoveAddressRequestAndWaitForReceiptAsync(RemoveAddress1Function removeAddress1Function, CancellationTokenSource cancellationToken = null)
        {
             return ContractHandler.SendRequestAndWaitForReceiptAsync(removeAddress1Function, cancellationToken);
        }

        public Task<string> RemoveAddressRequestAsync(byte[] setKey, string value)
        {
            var removeAddress1Function = new RemoveAddress1Function();
                removeAddress1Function.SetKey = setKey;
                removeAddress1Function.Value = value;
            
             return ContractHandler.SendRequestAsync(removeAddress1Function);
        }

        public Task<TransactionReceipt> RemoveAddressRequestAndWaitForReceiptAsync(byte[] setKey, string value, CancellationTokenSource cancellationToken = null)
        {
            var removeAddress1Function = new RemoveAddress1Function();
                removeAddress1Function.SetKey = setKey;
                removeAddress1Function.Value = value;
            
             return ContractHandler.SendRequestAndWaitForReceiptAsync(removeAddress1Function, cancellationToken);
        }

        public Task<string> RemoveAddressRequestAsync(RemoveAddressFunction removeAddressFunction)
        {
             return ContractHandler.SendRequestAsync(removeAddressFunction);
        }

        public Task<TransactionReceipt> RemoveAddressRequestAndWaitForReceiptAsync(RemoveAddressFunction removeAddressFunction, CancellationTokenSource cancellationToken = null)
        {
             return ContractHandler.SendRequestAndWaitForReceiptAsync(removeAddressFunction, cancellationToken);
        }

        public Task<string> RemoveAddressRequestAsync(byte[] key)
        {
            var removeAddressFunction = new RemoveAddressFunction();
                removeAddressFunction.Key = key;
            
             return ContractHandler.SendRequestAsync(removeAddressFunction);
        }

        public Task<TransactionReceipt> RemoveAddressRequestAndWaitForReceiptAsync(byte[] key, CancellationTokenSource cancellationToken = null)
        {
            var removeAddressFunction = new RemoveAddressFunction();
                removeAddressFunction.Key = key;
            
             return ContractHandler.SendRequestAndWaitForReceiptAsync(removeAddressFunction, cancellationToken);
        }

        public Task<string> RemoveAddressArrayRequestAsync(RemoveAddressArrayFunction removeAddressArrayFunction)
        {
             return ContractHandler.SendRequestAsync(removeAddressArrayFunction);
        }

        public Task<TransactionReceipt> RemoveAddressArrayRequestAndWaitForReceiptAsync(RemoveAddressArrayFunction removeAddressArrayFunction, CancellationTokenSource cancellationToken = null)
        {
             return ContractHandler.SendRequestAndWaitForReceiptAsync(removeAddressArrayFunction, cancellationToken);
        }

        public Task<string> RemoveAddressArrayRequestAsync(byte[] key)
        {
            var removeAddressArrayFunction = new RemoveAddressArrayFunction();
                removeAddressArrayFunction.Key = key;
            
             return ContractHandler.SendRequestAsync(removeAddressArrayFunction);
        }

        public Task<TransactionReceipt> RemoveAddressArrayRequestAndWaitForReceiptAsync(byte[] key, CancellationTokenSource cancellationToken = null)
        {
            var removeAddressArrayFunction = new RemoveAddressArrayFunction();
                removeAddressArrayFunction.Key = key;
            
             return ContractHandler.SendRequestAndWaitForReceiptAsync(removeAddressArrayFunction, cancellationToken);
        }

        public Task<string> RemoveBoolRequestAsync(RemoveBoolFunction removeBoolFunction)
        {
             return ContractHandler.SendRequestAsync(removeBoolFunction);
        }

        public Task<TransactionReceipt> RemoveBoolRequestAndWaitForReceiptAsync(RemoveBoolFunction removeBoolFunction, CancellationTokenSource cancellationToken = null)
        {
             return ContractHandler.SendRequestAndWaitForReceiptAsync(removeBoolFunction, cancellationToken);
        }

        public Task<string> RemoveBoolRequestAsync(byte[] key)
        {
            var removeBoolFunction = new RemoveBoolFunction();
                removeBoolFunction.Key = key;
            
             return ContractHandler.SendRequestAsync(removeBoolFunction);
        }

        public Task<TransactionReceipt> RemoveBoolRequestAndWaitForReceiptAsync(byte[] key, CancellationTokenSource cancellationToken = null)
        {
            var removeBoolFunction = new RemoveBoolFunction();
                removeBoolFunction.Key = key;
            
             return ContractHandler.SendRequestAndWaitForReceiptAsync(removeBoolFunction, cancellationToken);
        }

        public Task<string> RemoveBoolArrayRequestAsync(RemoveBoolArrayFunction removeBoolArrayFunction)
        {
             return ContractHandler.SendRequestAsync(removeBoolArrayFunction);
        }

        public Task<TransactionReceipt> RemoveBoolArrayRequestAndWaitForReceiptAsync(RemoveBoolArrayFunction removeBoolArrayFunction, CancellationTokenSource cancellationToken = null)
        {
             return ContractHandler.SendRequestAndWaitForReceiptAsync(removeBoolArrayFunction, cancellationToken);
        }

        public Task<string> RemoveBoolArrayRequestAsync(byte[] key)
        {
            var removeBoolArrayFunction = new RemoveBoolArrayFunction();
                removeBoolArrayFunction.Key = key;
            
             return ContractHandler.SendRequestAsync(removeBoolArrayFunction);
        }

        public Task<TransactionReceipt> RemoveBoolArrayRequestAndWaitForReceiptAsync(byte[] key, CancellationTokenSource cancellationToken = null)
        {
            var removeBoolArrayFunction = new RemoveBoolArrayFunction();
                removeBoolArrayFunction.Key = key;
            
             return ContractHandler.SendRequestAndWaitForReceiptAsync(removeBoolArrayFunction, cancellationToken);
        }

        public Task<string> RemoveBytes32RequestAsync(RemoveBytes321Function removeBytes321Function)
        {
             return ContractHandler.SendRequestAsync(removeBytes321Function);
        }

        public Task<TransactionReceipt> RemoveBytes32RequestAndWaitForReceiptAsync(RemoveBytes321Function removeBytes321Function, CancellationTokenSource cancellationToken = null)
        {
             return ContractHandler.SendRequestAndWaitForReceiptAsync(removeBytes321Function, cancellationToken);
        }

        public Task<string> RemoveBytes32RequestAsync(byte[] setKey, byte[] value)
        {
            var removeBytes321Function = new RemoveBytes321Function();
                removeBytes321Function.SetKey = setKey;
                removeBytes321Function.Value = value;
            
             return ContractHandler.SendRequestAsync(removeBytes321Function);
        }

        public Task<TransactionReceipt> RemoveBytes32RequestAndWaitForReceiptAsync(byte[] setKey, byte[] value, CancellationTokenSource cancellationToken = null)
        {
            var removeBytes321Function = new RemoveBytes321Function();
                removeBytes321Function.SetKey = setKey;
                removeBytes321Function.Value = value;
            
             return ContractHandler.SendRequestAndWaitForReceiptAsync(removeBytes321Function, cancellationToken);
        }

        public Task<string> RemoveBytes32RequestAsync(RemoveBytes32Function removeBytes32Function)
        {
             return ContractHandler.SendRequestAsync(removeBytes32Function);
        }

        public Task<TransactionReceipt> RemoveBytes32RequestAndWaitForReceiptAsync(RemoveBytes32Function removeBytes32Function, CancellationTokenSource cancellationToken = null)
        {
             return ContractHandler.SendRequestAndWaitForReceiptAsync(removeBytes32Function, cancellationToken);
        }

        public Task<string> RemoveBytes32RequestAsync(byte[] key)
        {
            var removeBytes32Function = new RemoveBytes32Function();
                removeBytes32Function.Key = key;
            
             return ContractHandler.SendRequestAsync(removeBytes32Function);
        }

        public Task<TransactionReceipt> RemoveBytes32RequestAndWaitForReceiptAsync(byte[] key, CancellationTokenSource cancellationToken = null)
        {
            var removeBytes32Function = new RemoveBytes32Function();
                removeBytes32Function.Key = key;
            
             return ContractHandler.SendRequestAndWaitForReceiptAsync(removeBytes32Function, cancellationToken);
        }

        public Task<string> RemoveBytes32ArrayRequestAsync(RemoveBytes32ArrayFunction removeBytes32ArrayFunction)
        {
             return ContractHandler.SendRequestAsync(removeBytes32ArrayFunction);
        }

        public Task<TransactionReceipt> RemoveBytes32ArrayRequestAndWaitForReceiptAsync(RemoveBytes32ArrayFunction removeBytes32ArrayFunction, CancellationTokenSource cancellationToken = null)
        {
             return ContractHandler.SendRequestAndWaitForReceiptAsync(removeBytes32ArrayFunction, cancellationToken);
        }

        public Task<string> RemoveBytes32ArrayRequestAsync(byte[] key)
        {
            var removeBytes32ArrayFunction = new RemoveBytes32ArrayFunction();
                removeBytes32ArrayFunction.Key = key;
            
             return ContractHandler.SendRequestAsync(removeBytes32ArrayFunction);
        }

        public Task<TransactionReceipt> RemoveBytes32ArrayRequestAndWaitForReceiptAsync(byte[] key, CancellationTokenSource cancellationToken = null)
        {
            var removeBytes32ArrayFunction = new RemoveBytes32ArrayFunction();
                removeBytes32ArrayFunction.Key = key;
            
             return ContractHandler.SendRequestAndWaitForReceiptAsync(removeBytes32ArrayFunction, cancellationToken);
        }

        public Task<string> RemoveIntRequestAsync(RemoveIntFunction removeIntFunction)
        {
             return ContractHandler.SendRequestAsync(removeIntFunction);
        }

        public Task<TransactionReceipt> RemoveIntRequestAndWaitForReceiptAsync(RemoveIntFunction removeIntFunction, CancellationTokenSource cancellationToken = null)
        {
             return ContractHandler.SendRequestAndWaitForReceiptAsync(removeIntFunction, cancellationToken);
        }

        public Task<string> RemoveIntRequestAsync(byte[] key)
        {
            var removeIntFunction = new RemoveIntFunction();
                removeIntFunction.Key = key;
            
             return ContractHandler.SendRequestAsync(removeIntFunction);
        }

        public Task<TransactionReceipt> RemoveIntRequestAndWaitForReceiptAsync(byte[] key, CancellationTokenSource cancellationToken = null)
        {
            var removeIntFunction = new RemoveIntFunction();
                removeIntFunction.Key = key;
            
             return ContractHandler.SendRequestAndWaitForReceiptAsync(removeIntFunction, cancellationToken);
        }

        public Task<string> RemoveIntArrayRequestAsync(RemoveIntArrayFunction removeIntArrayFunction)
        {
             return ContractHandler.SendRequestAsync(removeIntArrayFunction);
        }

        public Task<TransactionReceipt> RemoveIntArrayRequestAndWaitForReceiptAsync(RemoveIntArrayFunction removeIntArrayFunction, CancellationTokenSource cancellationToken = null)
        {
             return ContractHandler.SendRequestAndWaitForReceiptAsync(removeIntArrayFunction, cancellationToken);
        }

        public Task<string> RemoveIntArrayRequestAsync(byte[] key)
        {
            var removeIntArrayFunction = new RemoveIntArrayFunction();
                removeIntArrayFunction.Key = key;
            
             return ContractHandler.SendRequestAsync(removeIntArrayFunction);
        }

        public Task<TransactionReceipt> RemoveIntArrayRequestAndWaitForReceiptAsync(byte[] key, CancellationTokenSource cancellationToken = null)
        {
            var removeIntArrayFunction = new RemoveIntArrayFunction();
                removeIntArrayFunction.Key = key;
            
             return ContractHandler.SendRequestAndWaitForReceiptAsync(removeIntArrayFunction, cancellationToken);
        }

        public Task<string> RemoveStringRequestAsync(RemoveStringFunction removeStringFunction)
        {
             return ContractHandler.SendRequestAsync(removeStringFunction);
        }

        public Task<TransactionReceipt> RemoveStringRequestAndWaitForReceiptAsync(RemoveStringFunction removeStringFunction, CancellationTokenSource cancellationToken = null)
        {
             return ContractHandler.SendRequestAndWaitForReceiptAsync(removeStringFunction, cancellationToken);
        }

        public Task<string> RemoveStringRequestAsync(byte[] key)
        {
            var removeStringFunction = new RemoveStringFunction();
                removeStringFunction.Key = key;
            
             return ContractHandler.SendRequestAsync(removeStringFunction);
        }

        public Task<TransactionReceipt> RemoveStringRequestAndWaitForReceiptAsync(byte[] key, CancellationTokenSource cancellationToken = null)
        {
            var removeStringFunction = new RemoveStringFunction();
                removeStringFunction.Key = key;
            
             return ContractHandler.SendRequestAndWaitForReceiptAsync(removeStringFunction, cancellationToken);
        }

        public Task<string> RemoveStringArrayRequestAsync(RemoveStringArrayFunction removeStringArrayFunction)
        {
             return ContractHandler.SendRequestAsync(removeStringArrayFunction);
        }

        public Task<TransactionReceipt> RemoveStringArrayRequestAndWaitForReceiptAsync(RemoveStringArrayFunction removeStringArrayFunction, CancellationTokenSource cancellationToken = null)
        {
             return ContractHandler.SendRequestAndWaitForReceiptAsync(removeStringArrayFunction, cancellationToken);
        }

        public Task<string> RemoveStringArrayRequestAsync(byte[] key)
        {
            var removeStringArrayFunction = new RemoveStringArrayFunction();
                removeStringArrayFunction.Key = key;
            
             return ContractHandler.SendRequestAsync(removeStringArrayFunction);
        }

        public Task<TransactionReceipt> RemoveStringArrayRequestAndWaitForReceiptAsync(byte[] key, CancellationTokenSource cancellationToken = null)
        {
            var removeStringArrayFunction = new RemoveStringArrayFunction();
                removeStringArrayFunction.Key = key;
            
             return ContractHandler.SendRequestAndWaitForReceiptAsync(removeStringArrayFunction, cancellationToken);
        }

        public Task<string> RemoveUintRequestAsync(RemoveUintFunction removeUintFunction)
        {
             return ContractHandler.SendRequestAsync(removeUintFunction);
        }

        public Task<TransactionReceipt> RemoveUintRequestAndWaitForReceiptAsync(RemoveUintFunction removeUintFunction, CancellationTokenSource cancellationToken = null)
        {
             return ContractHandler.SendRequestAndWaitForReceiptAsync(removeUintFunction, cancellationToken);
        }

        public Task<string> RemoveUintRequestAsync(byte[] key)
        {
            var removeUintFunction = new RemoveUintFunction();
                removeUintFunction.Key = key;
            
             return ContractHandler.SendRequestAsync(removeUintFunction);
        }

        public Task<TransactionReceipt> RemoveUintRequestAndWaitForReceiptAsync(byte[] key, CancellationTokenSource cancellationToken = null)
        {
            var removeUintFunction = new RemoveUintFunction();
                removeUintFunction.Key = key;
            
             return ContractHandler.SendRequestAndWaitForReceiptAsync(removeUintFunction, cancellationToken);
        }

        public Task<string> RemoveUintRequestAsync(RemoveUint1Function removeUint1Function)
        {
             return ContractHandler.SendRequestAsync(removeUint1Function);
        }

        public Task<TransactionReceipt> RemoveUintRequestAndWaitForReceiptAsync(RemoveUint1Function removeUint1Function, CancellationTokenSource cancellationToken = null)
        {
             return ContractHandler.SendRequestAndWaitForReceiptAsync(removeUint1Function, cancellationToken);
        }

        public Task<string> RemoveUintRequestAsync(byte[] setKey, BigInteger value)
        {
            var removeUint1Function = new RemoveUint1Function();
                removeUint1Function.SetKey = setKey;
                removeUint1Function.Value = value;
            
             return ContractHandler.SendRequestAsync(removeUint1Function);
        }

        public Task<TransactionReceipt> RemoveUintRequestAndWaitForReceiptAsync(byte[] setKey, BigInteger value, CancellationTokenSource cancellationToken = null)
        {
            var removeUint1Function = new RemoveUint1Function();
                removeUint1Function.SetKey = setKey;
                removeUint1Function.Value = value;
            
             return ContractHandler.SendRequestAndWaitForReceiptAsync(removeUint1Function, cancellationToken);
        }

        public Task<string> RemoveUintArrayRequestAsync(RemoveUintArrayFunction removeUintArrayFunction)
        {
             return ContractHandler.SendRequestAsync(removeUintArrayFunction);
        }

        public Task<TransactionReceipt> RemoveUintArrayRequestAndWaitForReceiptAsync(RemoveUintArrayFunction removeUintArrayFunction, CancellationTokenSource cancellationToken = null)
        {
             return ContractHandler.SendRequestAndWaitForReceiptAsync(removeUintArrayFunction, cancellationToken);
        }

        public Task<string> RemoveUintArrayRequestAsync(byte[] key)
        {
            var removeUintArrayFunction = new RemoveUintArrayFunction();
                removeUintArrayFunction.Key = key;
            
             return ContractHandler.SendRequestAsync(removeUintArrayFunction);
        }

        public Task<TransactionReceipt> RemoveUintArrayRequestAndWaitForReceiptAsync(byte[] key, CancellationTokenSource cancellationToken = null)
        {
            var removeUintArrayFunction = new RemoveUintArrayFunction();
                removeUintArrayFunction.Key = key;
            
             return ContractHandler.SendRequestAndWaitForReceiptAsync(removeUintArrayFunction, cancellationToken);
        }

        public Task<string> RoleStoreQueryAsync(RoleStoreFunction roleStoreFunction, BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<RoleStoreFunction, string>(roleStoreFunction, blockParameter);
        }

        
        public Task<string> RoleStoreQueryAsync(BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<RoleStoreFunction, string>(null, blockParameter);
        }

        public Task<string> SetAddressRequestAsync(SetAddressFunction setAddressFunction)
        {
             return ContractHandler.SendRequestAsync(setAddressFunction);
        }

        public Task<TransactionReceipt> SetAddressRequestAndWaitForReceiptAsync(SetAddressFunction setAddressFunction, CancellationTokenSource cancellationToken = null)
        {
             return ContractHandler.SendRequestAndWaitForReceiptAsync(setAddressFunction, cancellationToken);
        }

        public Task<string> SetAddressRequestAsync(byte[] key, string value)
        {
            var setAddressFunction = new SetAddressFunction();
                setAddressFunction.Key = key;
                setAddressFunction.Value = value;
            
             return ContractHandler.SendRequestAsync(setAddressFunction);
        }

        public Task<TransactionReceipt> SetAddressRequestAndWaitForReceiptAsync(byte[] key, string value, CancellationTokenSource cancellationToken = null)
        {
            var setAddressFunction = new SetAddressFunction();
                setAddressFunction.Key = key;
                setAddressFunction.Value = value;
            
             return ContractHandler.SendRequestAndWaitForReceiptAsync(setAddressFunction, cancellationToken);
        }

        public Task<string> SetAddressArrayRequestAsync(SetAddressArrayFunction setAddressArrayFunction)
        {
             return ContractHandler.SendRequestAsync(setAddressArrayFunction);
        }

        public Task<TransactionReceipt> SetAddressArrayRequestAndWaitForReceiptAsync(SetAddressArrayFunction setAddressArrayFunction, CancellationTokenSource cancellationToken = null)
        {
             return ContractHandler.SendRequestAndWaitForReceiptAsync(setAddressArrayFunction, cancellationToken);
        }

        public Task<string> SetAddressArrayRequestAsync(byte[] key, List<string> value)
        {
            var setAddressArrayFunction = new SetAddressArrayFunction();
                setAddressArrayFunction.Key = key;
                setAddressArrayFunction.Value = value;
            
             return ContractHandler.SendRequestAsync(setAddressArrayFunction);
        }

        public Task<TransactionReceipt> SetAddressArrayRequestAndWaitForReceiptAsync(byte[] key, List<string> value, CancellationTokenSource cancellationToken = null)
        {
            var setAddressArrayFunction = new SetAddressArrayFunction();
                setAddressArrayFunction.Key = key;
                setAddressArrayFunction.Value = value;
            
             return ContractHandler.SendRequestAndWaitForReceiptAsync(setAddressArrayFunction, cancellationToken);
        }

        public Task<string> SetBoolRequestAsync(SetBoolFunction setBoolFunction)
        {
             return ContractHandler.SendRequestAsync(setBoolFunction);
        }

        public Task<TransactionReceipt> SetBoolRequestAndWaitForReceiptAsync(SetBoolFunction setBoolFunction, CancellationTokenSource cancellationToken = null)
        {
             return ContractHandler.SendRequestAndWaitForReceiptAsync(setBoolFunction, cancellationToken);
        }

        public Task<string> SetBoolRequestAsync(byte[] key, bool value)
        {
            var setBoolFunction = new SetBoolFunction();
                setBoolFunction.Key = key;
                setBoolFunction.Value = value;
            
             return ContractHandler.SendRequestAsync(setBoolFunction);
        }

        public Task<TransactionReceipt> SetBoolRequestAndWaitForReceiptAsync(byte[] key, bool value, CancellationTokenSource cancellationToken = null)
        {
            var setBoolFunction = new SetBoolFunction();
                setBoolFunction.Key = key;
                setBoolFunction.Value = value;
            
             return ContractHandler.SendRequestAndWaitForReceiptAsync(setBoolFunction, cancellationToken);
        }

        public Task<string> SetBoolArrayRequestAsync(SetBoolArrayFunction setBoolArrayFunction)
        {
             return ContractHandler.SendRequestAsync(setBoolArrayFunction);
        }

        public Task<TransactionReceipt> SetBoolArrayRequestAndWaitForReceiptAsync(SetBoolArrayFunction setBoolArrayFunction, CancellationTokenSource cancellationToken = null)
        {
             return ContractHandler.SendRequestAndWaitForReceiptAsync(setBoolArrayFunction, cancellationToken);
        }

        public Task<string> SetBoolArrayRequestAsync(byte[] key, List<bool> value)
        {
            var setBoolArrayFunction = new SetBoolArrayFunction();
                setBoolArrayFunction.Key = key;
                setBoolArrayFunction.Value = value;
            
             return ContractHandler.SendRequestAsync(setBoolArrayFunction);
        }

        public Task<TransactionReceipt> SetBoolArrayRequestAndWaitForReceiptAsync(byte[] key, List<bool> value, CancellationTokenSource cancellationToken = null)
        {
            var setBoolArrayFunction = new SetBoolArrayFunction();
                setBoolArrayFunction.Key = key;
                setBoolArrayFunction.Value = value;
            
             return ContractHandler.SendRequestAndWaitForReceiptAsync(setBoolArrayFunction, cancellationToken);
        }

        public Task<string> SetBytes32RequestAsync(SetBytes32Function setBytes32Function)
        {
             return ContractHandler.SendRequestAsync(setBytes32Function);
        }

        public Task<TransactionReceipt> SetBytes32RequestAndWaitForReceiptAsync(SetBytes32Function setBytes32Function, CancellationTokenSource cancellationToken = null)
        {
             return ContractHandler.SendRequestAndWaitForReceiptAsync(setBytes32Function, cancellationToken);
        }

        public Task<string> SetBytes32RequestAsync(byte[] key, byte[] value)
        {
            var setBytes32Function = new SetBytes32Function();
                setBytes32Function.Key = key;
                setBytes32Function.Value = value;
            
             return ContractHandler.SendRequestAsync(setBytes32Function);
        }

        public Task<TransactionReceipt> SetBytes32RequestAndWaitForReceiptAsync(byte[] key, byte[] value, CancellationTokenSource cancellationToken = null)
        {
            var setBytes32Function = new SetBytes32Function();
                setBytes32Function.Key = key;
                setBytes32Function.Value = value;
            
             return ContractHandler.SendRequestAndWaitForReceiptAsync(setBytes32Function, cancellationToken);
        }

        public Task<string> SetBytes32ArrayRequestAsync(SetBytes32ArrayFunction setBytes32ArrayFunction)
        {
             return ContractHandler.SendRequestAsync(setBytes32ArrayFunction);
        }

        public Task<TransactionReceipt> SetBytes32ArrayRequestAndWaitForReceiptAsync(SetBytes32ArrayFunction setBytes32ArrayFunction, CancellationTokenSource cancellationToken = null)
        {
             return ContractHandler.SendRequestAndWaitForReceiptAsync(setBytes32ArrayFunction, cancellationToken);
        }

        public Task<string> SetBytes32ArrayRequestAsync(byte[] key, List<byte[]> value)
        {
            var setBytes32ArrayFunction = new SetBytes32ArrayFunction();
                setBytes32ArrayFunction.Key = key;
                setBytes32ArrayFunction.Value = value;
            
             return ContractHandler.SendRequestAsync(setBytes32ArrayFunction);
        }

        public Task<TransactionReceipt> SetBytes32ArrayRequestAndWaitForReceiptAsync(byte[] key, List<byte[]> value, CancellationTokenSource cancellationToken = null)
        {
            var setBytes32ArrayFunction = new SetBytes32ArrayFunction();
                setBytes32ArrayFunction.Key = key;
                setBytes32ArrayFunction.Value = value;
            
             return ContractHandler.SendRequestAndWaitForReceiptAsync(setBytes32ArrayFunction, cancellationToken);
        }

        public Task<string> SetIntRequestAsync(SetIntFunction setIntFunction)
        {
             return ContractHandler.SendRequestAsync(setIntFunction);
        }

        public Task<TransactionReceipt> SetIntRequestAndWaitForReceiptAsync(SetIntFunction setIntFunction, CancellationTokenSource cancellationToken = null)
        {
             return ContractHandler.SendRequestAndWaitForReceiptAsync(setIntFunction, cancellationToken);
        }

        public Task<string> SetIntRequestAsync(byte[] key, BigInteger value)
        {
            var setIntFunction = new SetIntFunction();
                setIntFunction.Key = key;
                setIntFunction.Value = value;
            
             return ContractHandler.SendRequestAsync(setIntFunction);
        }

        public Task<TransactionReceipt> SetIntRequestAndWaitForReceiptAsync(byte[] key, BigInteger value, CancellationTokenSource cancellationToken = null)
        {
            var setIntFunction = new SetIntFunction();
                setIntFunction.Key = key;
                setIntFunction.Value = value;
            
             return ContractHandler.SendRequestAndWaitForReceiptAsync(setIntFunction, cancellationToken);
        }

        public Task<string> SetIntArrayRequestAsync(SetIntArrayFunction setIntArrayFunction)
        {
             return ContractHandler.SendRequestAsync(setIntArrayFunction);
        }

        public Task<TransactionReceipt> SetIntArrayRequestAndWaitForReceiptAsync(SetIntArrayFunction setIntArrayFunction, CancellationTokenSource cancellationToken = null)
        {
             return ContractHandler.SendRequestAndWaitForReceiptAsync(setIntArrayFunction, cancellationToken);
        }

        public Task<string> SetIntArrayRequestAsync(byte[] key, List<BigInteger> value)
        {
            var setIntArrayFunction = new SetIntArrayFunction();
                setIntArrayFunction.Key = key;
                setIntArrayFunction.Value = value;
            
             return ContractHandler.SendRequestAsync(setIntArrayFunction);
        }

        public Task<TransactionReceipt> SetIntArrayRequestAndWaitForReceiptAsync(byte[] key, List<BigInteger> value, CancellationTokenSource cancellationToken = null)
        {
            var setIntArrayFunction = new SetIntArrayFunction();
                setIntArrayFunction.Key = key;
                setIntArrayFunction.Value = value;
            
             return ContractHandler.SendRequestAndWaitForReceiptAsync(setIntArrayFunction, cancellationToken);
        }

        public Task<string> SetStringRequestAsync(SetStringFunction setStringFunction)
        {
             return ContractHandler.SendRequestAsync(setStringFunction);
        }

        public Task<TransactionReceipt> SetStringRequestAndWaitForReceiptAsync(SetStringFunction setStringFunction, CancellationTokenSource cancellationToken = null)
        {
             return ContractHandler.SendRequestAndWaitForReceiptAsync(setStringFunction, cancellationToken);
        }

        public Task<string> SetStringRequestAsync(byte[] key, string value)
        {
            var setStringFunction = new SetStringFunction();
                setStringFunction.Key = key;
                setStringFunction.Value = value;
            
             return ContractHandler.SendRequestAsync(setStringFunction);
        }

        public Task<TransactionReceipt> SetStringRequestAndWaitForReceiptAsync(byte[] key, string value, CancellationTokenSource cancellationToken = null)
        {
            var setStringFunction = new SetStringFunction();
                setStringFunction.Key = key;
                setStringFunction.Value = value;
            
             return ContractHandler.SendRequestAndWaitForReceiptAsync(setStringFunction, cancellationToken);
        }

        public Task<string> SetStringArrayRequestAsync(SetStringArrayFunction setStringArrayFunction)
        {
             return ContractHandler.SendRequestAsync(setStringArrayFunction);
        }

        public Task<TransactionReceipt> SetStringArrayRequestAndWaitForReceiptAsync(SetStringArrayFunction setStringArrayFunction, CancellationTokenSource cancellationToken = null)
        {
             return ContractHandler.SendRequestAndWaitForReceiptAsync(setStringArrayFunction, cancellationToken);
        }

        public Task<string> SetStringArrayRequestAsync(byte[] key, List<string> value)
        {
            var setStringArrayFunction = new SetStringArrayFunction();
                setStringArrayFunction.Key = key;
                setStringArrayFunction.Value = value;
            
             return ContractHandler.SendRequestAsync(setStringArrayFunction);
        }

        public Task<TransactionReceipt> SetStringArrayRequestAndWaitForReceiptAsync(byte[] key, List<string> value, CancellationTokenSource cancellationToken = null)
        {
            var setStringArrayFunction = new SetStringArrayFunction();
                setStringArrayFunction.Key = key;
                setStringArrayFunction.Value = value;
            
             return ContractHandler.SendRequestAndWaitForReceiptAsync(setStringArrayFunction, cancellationToken);
        }

        public Task<string> SetUintRequestAsync(SetUintFunction setUintFunction)
        {
             return ContractHandler.SendRequestAsync(setUintFunction);
        }

        public Task<TransactionReceipt> SetUintRequestAndWaitForReceiptAsync(SetUintFunction setUintFunction, CancellationTokenSource cancellationToken = null)
        {
             return ContractHandler.SendRequestAndWaitForReceiptAsync(setUintFunction, cancellationToken);
        }

        public Task<string> SetUintRequestAsync(byte[] key, BigInteger value)
        {
            var setUintFunction = new SetUintFunction();
                setUintFunction.Key = key;
                setUintFunction.Value = value;
            
             return ContractHandler.SendRequestAsync(setUintFunction);
        }

        public Task<TransactionReceipt> SetUintRequestAndWaitForReceiptAsync(byte[] key, BigInteger value, CancellationTokenSource cancellationToken = null)
        {
            var setUintFunction = new SetUintFunction();
                setUintFunction.Key = key;
                setUintFunction.Value = value;
            
             return ContractHandler.SendRequestAndWaitForReceiptAsync(setUintFunction, cancellationToken);
        }

        public Task<string> SetUintArrayRequestAsync(SetUintArrayFunction setUintArrayFunction)
        {
             return ContractHandler.SendRequestAsync(setUintArrayFunction);
        }

        public Task<TransactionReceipt> SetUintArrayRequestAndWaitForReceiptAsync(SetUintArrayFunction setUintArrayFunction, CancellationTokenSource cancellationToken = null)
        {
             return ContractHandler.SendRequestAndWaitForReceiptAsync(setUintArrayFunction, cancellationToken);
        }

        public Task<string> SetUintArrayRequestAsync(byte[] key, List<BigInteger> value)
        {
            var setUintArrayFunction = new SetUintArrayFunction();
                setUintArrayFunction.Key = key;
                setUintArrayFunction.Value = value;
            
             return ContractHandler.SendRequestAsync(setUintArrayFunction);
        }

        public Task<TransactionReceipt> SetUintArrayRequestAndWaitForReceiptAsync(byte[] key, List<BigInteger> value, CancellationTokenSource cancellationToken = null)
        {
            var setUintArrayFunction = new SetUintArrayFunction();
                setUintArrayFunction.Key = key;
                setUintArrayFunction.Value = value;
            
             return ContractHandler.SendRequestAndWaitForReceiptAsync(setUintArrayFunction, cancellationToken);
        }

        public Task<string> StringArrayValuesQueryAsync(StringArrayValuesFunction stringArrayValuesFunction, BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<StringArrayValuesFunction, string>(stringArrayValuesFunction, blockParameter);
        }

        
        public Task<string> StringArrayValuesQueryAsync(byte[] returnValue1, BigInteger returnValue2, BlockParameter blockParameter = null)
        {
            var stringArrayValuesFunction = new StringArrayValuesFunction();
                stringArrayValuesFunction.ReturnValue1 = returnValue1;
                stringArrayValuesFunction.ReturnValue2 = returnValue2;
            
            return ContractHandler.QueryAsync<StringArrayValuesFunction, string>(stringArrayValuesFunction, blockParameter);
        }

        public Task<string> StringValuesQueryAsync(StringValuesFunction stringValuesFunction, BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<StringValuesFunction, string>(stringValuesFunction, blockParameter);
        }

        
        public Task<string> StringValuesQueryAsync(byte[] returnValue1, BlockParameter blockParameter = null)
        {
            var stringValuesFunction = new StringValuesFunction();
                stringValuesFunction.ReturnValue1 = returnValue1;
            
            return ContractHandler.QueryAsync<StringValuesFunction, string>(stringValuesFunction, blockParameter);
        }

        public Task<BigInteger> UintArrayValuesQueryAsync(UintArrayValuesFunction uintArrayValuesFunction, BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<UintArrayValuesFunction, BigInteger>(uintArrayValuesFunction, blockParameter);
        }

        
        public Task<BigInteger> UintArrayValuesQueryAsync(byte[] returnValue1, BigInteger returnValue2, BlockParameter blockParameter = null)
        {
            var uintArrayValuesFunction = new UintArrayValuesFunction();
                uintArrayValuesFunction.ReturnValue1 = returnValue1;
                uintArrayValuesFunction.ReturnValue2 = returnValue2;
            
            return ContractHandler.QueryAsync<UintArrayValuesFunction, BigInteger>(uintArrayValuesFunction, blockParameter);
        }

        public Task<BigInteger> UintValuesQueryAsync(UintValuesFunction uintValuesFunction, BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<UintValuesFunction, BigInteger>(uintValuesFunction, blockParameter);
        }

        
        public Task<BigInteger> UintValuesQueryAsync(byte[] returnValue1, BlockParameter blockParameter = null)
        {
            var uintValuesFunction = new UintValuesFunction();
                uintValuesFunction.ReturnValue1 = returnValue1;
            
            return ContractHandler.QueryAsync<UintValuesFunction, BigInteger>(uintValuesFunction, blockParameter);
        }

        public override List<Type> GetAllFunctionTypes()
        {
            return new List<Type>
            {
                typeof(AddAddressFunction),
                typeof(AddBytes32Function),
                typeof(AddUintFunction),
                typeof(AddressArrayValuesFunction),
                typeof(AddressValuesFunction),
                typeof(ApplyBoundedDeltaToUintFunction),
                typeof(ApplyDeltaToIntFunction),
                typeof(ApplyDeltaToUint1Function),
                typeof(ApplyDeltaToUintFunction),
                typeof(BoolArrayValuesFunction),
                typeof(BoolValuesFunction),
                typeof(Bytes32ArrayValuesFunction),
                typeof(Bytes32ValuesFunction),
                typeof(ContainsAddressFunction),
                typeof(ContainsBytes32Function),
                typeof(ContainsUintFunction),
                typeof(DecrementIntFunction),
                typeof(DecrementUintFunction),
                typeof(GetAddressFunction),
                typeof(GetAddressArrayFunction),
                typeof(GetAddressCountFunction),
                typeof(GetAddressValuesAtFunction),
                typeof(GetBoolFunction),
                typeof(GetBoolArrayFunction),
                typeof(GetBytes32Function),
                typeof(GetBytes32ArrayFunction),
                typeof(GetBytes32CountFunction),
                typeof(GetBytes32ValuesAtFunction),
                typeof(GetIntFunction),
                typeof(GetIntArrayFunction),
                typeof(GetStringFunction),
                typeof(GetStringArrayFunction),
                typeof(GetUintFunction),
                typeof(GetUintArrayFunction),
                typeof(GetUintCountFunction),
                typeof(GetUintValuesAtFunction),
                typeof(IncrementIntFunction),
                typeof(IncrementUintFunction),
                typeof(IntArrayValuesFunction),
                typeof(IntValuesFunction),
                typeof(RemoveAddress1Function),
                typeof(RemoveAddressFunction),
                typeof(RemoveAddressArrayFunction),
                typeof(RemoveBoolFunction),
                typeof(RemoveBoolArrayFunction),
                typeof(RemoveBytes321Function),
                typeof(RemoveBytes32Function),
                typeof(RemoveBytes32ArrayFunction),
                typeof(RemoveIntFunction),
                typeof(RemoveIntArrayFunction),
                typeof(RemoveStringFunction),
                typeof(RemoveStringArrayFunction),
                typeof(RemoveUintFunction),
                typeof(RemoveUint1Function),
                typeof(RemoveUintArrayFunction),
                typeof(RoleStoreFunction),
                typeof(SetAddressFunction),
                typeof(SetAddressArrayFunction),
                typeof(SetBoolFunction),
                typeof(SetBoolArrayFunction),
                typeof(SetBytes32Function),
                typeof(SetBytes32ArrayFunction),
                typeof(SetIntFunction),
                typeof(SetIntArrayFunction),
                typeof(SetStringFunction),
                typeof(SetStringArrayFunction),
                typeof(SetUintFunction),
                typeof(SetUintArrayFunction),
                typeof(StringArrayValuesFunction),
                typeof(StringValuesFunction),
                typeof(UintArrayValuesFunction),
                typeof(UintValuesFunction)
            };
        }

        public override List<Type> GetAllEventTypes()
        {
            return new List<Type>
            {

            };
        }

        public override List<Type> GetAllErrorTypes()
        {
            return new List<Type>
            {
                typeof(UnauthorizedError)
            };
        }
    }
}
