using System.Numerics;
using Nethereum.ABI.FunctionEncoding.Attributes;
using Nethereum.Contracts;

namespace Managing.ABI.GmxV2.DataStore.ContractDefinition
{


    public partial class DataStoreDeployment : DataStoreDeploymentBase
    {
        public DataStoreDeployment() : base(BYTECODE) { }
        public DataStoreDeployment(string byteCode) : base(byteCode) { }
    }

    public class DataStoreDeploymentBase : ContractDeploymentMessage
    {
        public static string BYTECODE = " ";
        public DataStoreDeploymentBase() : base(BYTECODE) { }
        public DataStoreDeploymentBase(string byteCode) : base(byteCode) { }
        [Parameter("address", "_roleStore", 1)]
        public virtual string RoleStore { get; set; }
    }

    public partial class AddAddressFunction : AddAddressFunctionBase { }

    [Function("addAddress")]
    public class AddAddressFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "setKey", 1)]
        public virtual byte[] SetKey { get; set; }
        [Parameter("address", "value", 2)]
        public virtual string Value { get; set; }
    }

    public partial class AddBytes32Function : AddBytes32FunctionBase { }

    [Function("addBytes32")]
    public class AddBytes32FunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "setKey", 1)]
        public virtual byte[] SetKey { get; set; }
        [Parameter("bytes32", "value", 2)]
        public virtual byte[] Value { get; set; }
    }

    public partial class AddUintFunction : AddUintFunctionBase { }

    [Function("addUint")]
    public class AddUintFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "setKey", 1)]
        public virtual byte[] SetKey { get; set; }
        [Parameter("uint256", "value", 2)]
        public virtual BigInteger Value { get; set; }
    }

    public partial class AddressArrayValuesFunction : AddressArrayValuesFunctionBase { }

    [Function("addressArrayValues", "address")]
    public class AddressArrayValuesFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "", 1)]
        public virtual byte[] ReturnValue1 { get; set; }
        [Parameter("uint256", "", 2)]
        public virtual BigInteger ReturnValue2 { get; set; }
    }

    public partial class AddressValuesFunction : AddressValuesFunctionBase { }

    [Function("addressValues", "address")]
    public class AddressValuesFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "", 1)]
        public virtual byte[] ReturnValue1 { get; set; }
    }

    public partial class ApplyBoundedDeltaToUintFunction : ApplyBoundedDeltaToUintFunctionBase { }

    [Function("applyBoundedDeltaToUint", "uint256")]
    public class ApplyBoundedDeltaToUintFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)]
        public virtual byte[] Key { get; set; }
        [Parameter("int256", "value", 2)]
        public virtual BigInteger Value { get; set; }
    }

    public partial class ApplyDeltaToIntFunction : ApplyDeltaToIntFunctionBase { }

    [Function("applyDeltaToInt", "int256")]
    public class ApplyDeltaToIntFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)]
        public virtual byte[] Key { get; set; }
        [Parameter("int256", "value", 2)]
        public virtual BigInteger Value { get; set; }
    }

    public partial class ApplyDeltaToUint1Function : ApplyDeltaToUint1FunctionBase { }

    [Function("applyDeltaToUint", "uint256")]
    public class ApplyDeltaToUint1FunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)]
        public virtual byte[] Key { get; set; }
        [Parameter("int256", "value", 2)]
        public virtual BigInteger Value { get; set; }
        [Parameter("string", "errorMessage", 3)]
        public virtual string ErrorMessage { get; set; }
    }

    public partial class ApplyDeltaToUintFunction : ApplyDeltaToUintFunctionBase { }

    [Function("applyDeltaToUint", "uint256")]
    public class ApplyDeltaToUintFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)]
        public virtual byte[] Key { get; set; }
        [Parameter("uint256", "value", 2)]
        public virtual BigInteger Value { get; set; }
    }

    public partial class BoolArrayValuesFunction : BoolArrayValuesFunctionBase { }

    [Function("boolArrayValues", "bool")]
    public class BoolArrayValuesFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "", 1)]
        public virtual byte[] ReturnValue1 { get; set; }
        [Parameter("uint256", "", 2)]
        public virtual BigInteger ReturnValue2 { get; set; }
    }

    public partial class BoolValuesFunction : BoolValuesFunctionBase { }

    [Function("boolValues", "bool")]
    public class BoolValuesFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "", 1)]
        public virtual byte[] ReturnValue1 { get; set; }
    }

    public partial class Bytes32ArrayValuesFunction : Bytes32ArrayValuesFunctionBase { }

    [Function("bytes32ArrayValues", "bytes32")]
    public class Bytes32ArrayValuesFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "", 1)]
        public virtual byte[] ReturnValue1 { get; set; }
        [Parameter("uint256", "", 2)]
        public virtual BigInteger ReturnValue2 { get; set; }
    }

    public partial class Bytes32ValuesFunction : Bytes32ValuesFunctionBase { }

    [Function("bytes32Values", "bytes32")]
    public class Bytes32ValuesFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "", 1)]
        public virtual byte[] ReturnValue1 { get; set; }
    }

    public partial class ContainsAddressFunction : ContainsAddressFunctionBase { }

    [Function("containsAddress", "bool")]
    public class ContainsAddressFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "setKey", 1)]
        public virtual byte[] SetKey { get; set; }
        [Parameter("address", "value", 2)]
        public virtual string Value { get; set; }
    }

    public partial class ContainsBytes32Function : ContainsBytes32FunctionBase { }

    [Function("containsBytes32", "bool")]
    public class ContainsBytes32FunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "setKey", 1)]
        public virtual byte[] SetKey { get; set; }
        [Parameter("bytes32", "value", 2)]
        public virtual byte[] Value { get; set; }
    }

    public partial class ContainsUintFunction : ContainsUintFunctionBase { }

    [Function("containsUint", "bool")]
    public class ContainsUintFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "setKey", 1)]
        public virtual byte[] SetKey { get; set; }
        [Parameter("uint256", "value", 2)]
        public virtual BigInteger Value { get; set; }
    }

    public partial class DecrementIntFunction : DecrementIntFunctionBase { }

    [Function("decrementInt", "int256")]
    public class DecrementIntFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)]
        public virtual byte[] Key { get; set; }
        [Parameter("int256", "value", 2)]
        public virtual BigInteger Value { get; set; }
    }

    public partial class DecrementUintFunction : DecrementUintFunctionBase { }

    [Function("decrementUint", "uint256")]
    public class DecrementUintFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)]
        public virtual byte[] Key { get; set; }
        [Parameter("uint256", "value", 2)]
        public virtual BigInteger Value { get; set; }
    }

    public partial class GetAddressFunction : GetAddressFunctionBase { }

    [Function("getAddress", "address")]
    public class GetAddressFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)]
        public virtual byte[] Key { get; set; }
    }

    public partial class GetAddressArrayFunction : GetAddressArrayFunctionBase { }

    [Function("getAddressArray", "address[]")]
    public class GetAddressArrayFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)]
        public virtual byte[] Key { get; set; }
    }

    public partial class GetAddressCountFunction : GetAddressCountFunctionBase { }

    [Function("getAddressCount", "uint256")]
    public class GetAddressCountFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "setKey", 1)]
        public virtual byte[] SetKey { get; set; }
    }

    public partial class GetAddressValuesAtFunction : GetAddressValuesAtFunctionBase { }

    [Function("getAddressValuesAt", "address[]")]
    public class GetAddressValuesAtFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "setKey", 1)]
        public virtual byte[] SetKey { get; set; }
        [Parameter("uint256", "start", 2)]
        public virtual BigInteger Start { get; set; }
        [Parameter("uint256", "end", 3)]
        public virtual BigInteger End { get; set; }
    }

    public partial class GetBoolFunction : GetBoolFunctionBase { }

    [Function("getBool", "bool")]
    public class GetBoolFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)]
        public virtual byte[] Key { get; set; }
    }

    public partial class GetBoolArrayFunction : GetBoolArrayFunctionBase { }

    [Function("getBoolArray", "bool[]")]
    public class GetBoolArrayFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)]
        public virtual byte[] Key { get; set; }
    }

    public partial class GetBytes32Function : GetBytes32FunctionBase { }

    [Function("getBytes32", "bytes32")]
    public class GetBytes32FunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)]
        public virtual byte[] Key { get; set; }
    }

    public partial class GetBytes32ArrayFunction : GetBytes32ArrayFunctionBase { }

    [Function("getBytes32Array", "bytes32[]")]
    public class GetBytes32ArrayFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)]
        public virtual byte[] Key { get; set; }
    }

    public partial class GetBytes32CountFunction : GetBytes32CountFunctionBase { }

    [Function("getBytes32Count", "uint256")]
    public class GetBytes32CountFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "setKey", 1)]
        public virtual byte[] SetKey { get; set; }
    }

    public partial class GetBytes32ValuesAtFunction : GetBytes32ValuesAtFunctionBase { }

    [Function("getBytes32ValuesAt", "bytes32[]")]
    public class GetBytes32ValuesAtFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "setKey", 1)]
        public virtual byte[] SetKey { get; set; }
        [Parameter("uint256", "start", 2)]
        public virtual BigInteger Start { get; set; }
        [Parameter("uint256", "end", 3)]
        public virtual BigInteger End { get; set; }
    }

    public partial class GetIntFunction : GetIntFunctionBase { }

    [Function("getInt", "int256")]
    public class GetIntFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)]
        public virtual byte[] Key { get; set; }
    }

    public partial class GetIntArrayFunction : GetIntArrayFunctionBase { }

    [Function("getIntArray", "int256[]")]
    public class GetIntArrayFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)]
        public virtual byte[] Key { get; set; }
    }

    public partial class GetStringFunction : GetStringFunctionBase { }

    [Function("getString", "string")]
    public class GetStringFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)]
        public virtual byte[] Key { get; set; }
    }

    public partial class GetStringArrayFunction : GetStringArrayFunctionBase { }

    [Function("getStringArray", "string[]")]
    public class GetStringArrayFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)]
        public virtual byte[] Key { get; set; }
    }

    public partial class GetUintFunction : GetUintFunctionBase { }

    [Function("getUint", "uint256")]
    public class GetUintFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)]
        public virtual byte[] Key { get; set; }
    }

    public partial class GetUintArrayFunction : GetUintArrayFunctionBase { }

    [Function("getUintArray", "uint256[]")]
    public class GetUintArrayFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)]
        public virtual byte[] Key { get; set; }
    }

    public partial class GetUintCountFunction : GetUintCountFunctionBase { }

    [Function("getUintCount", "uint256")]
    public class GetUintCountFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "setKey", 1)]
        public virtual byte[] SetKey { get; set; }
    }

    public partial class GetUintValuesAtFunction : GetUintValuesAtFunctionBase { }

    [Function("getUintValuesAt", "uint256[]")]
    public class GetUintValuesAtFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "setKey", 1)]
        public virtual byte[] SetKey { get; set; }
        [Parameter("uint256", "start", 2)]
        public virtual BigInteger Start { get; set; }
        [Parameter("uint256", "end", 3)]
        public virtual BigInteger End { get; set; }
    }

    public partial class IncrementIntFunction : IncrementIntFunctionBase { }

    [Function("incrementInt", "int256")]
    public class IncrementIntFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)]
        public virtual byte[] Key { get; set; }
        [Parameter("int256", "value", 2)]
        public virtual BigInteger Value { get; set; }
    }

    public partial class IncrementUintFunction : IncrementUintFunctionBase { }

    [Function("incrementUint", "uint256")]
    public class IncrementUintFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)]
        public virtual byte[] Key { get; set; }
        [Parameter("uint256", "value", 2)]
        public virtual BigInteger Value { get; set; }
    }

    public partial class IntArrayValuesFunction : IntArrayValuesFunctionBase { }

    [Function("intArrayValues", "int256")]
    public class IntArrayValuesFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "", 1)]
        public virtual byte[] ReturnValue1 { get; set; }
        [Parameter("uint256", "", 2)]
        public virtual BigInteger ReturnValue2 { get; set; }
    }

    public partial class IntValuesFunction : IntValuesFunctionBase { }

    [Function("intValues", "int256")]
    public class IntValuesFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "", 1)]
        public virtual byte[] ReturnValue1 { get; set; }
    }

    public partial class RemoveAddress1Function : RemoveAddress1FunctionBase { }

    [Function("removeAddress")]
    public class RemoveAddress1FunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "setKey", 1)]
        public virtual byte[] SetKey { get; set; }
        [Parameter("address", "value", 2)]
        public virtual string Value { get; set; }
    }

    public partial class RemoveAddressFunction : RemoveAddressFunctionBase { }

    [Function("removeAddress")]
    public class RemoveAddressFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)]
        public virtual byte[] Key { get; set; }
    }

    public partial class RemoveAddressArrayFunction : RemoveAddressArrayFunctionBase { }

    [Function("removeAddressArray")]
    public class RemoveAddressArrayFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)]
        public virtual byte[] Key { get; set; }
    }

    public partial class RemoveBoolFunction : RemoveBoolFunctionBase { }

    [Function("removeBool")]
    public class RemoveBoolFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)]
        public virtual byte[] Key { get; set; }
    }

    public partial class RemoveBoolArrayFunction : RemoveBoolArrayFunctionBase { }

    [Function("removeBoolArray")]
    public class RemoveBoolArrayFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)]
        public virtual byte[] Key { get; set; }
    }

    public partial class RemoveBytes321Function : RemoveBytes321FunctionBase { }

    [Function("removeBytes32")]
    public class RemoveBytes321FunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "setKey", 1)]
        public virtual byte[] SetKey { get; set; }
        [Parameter("bytes32", "value", 2)]
        public virtual byte[] Value { get; set; }
    }

    public partial class RemoveBytes32Function : RemoveBytes32FunctionBase { }

    [Function("removeBytes32")]
    public class RemoveBytes32FunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)]
        public virtual byte[] Key { get; set; }
    }

    public partial class RemoveBytes32ArrayFunction : RemoveBytes32ArrayFunctionBase { }

    [Function("removeBytes32Array")]
    public class RemoveBytes32ArrayFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)]
        public virtual byte[] Key { get; set; }
    }

    public partial class RemoveIntFunction : RemoveIntFunctionBase { }

    [Function("removeInt")]
    public class RemoveIntFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)]
        public virtual byte[] Key { get; set; }
    }

    public partial class RemoveIntArrayFunction : RemoveIntArrayFunctionBase { }

    [Function("removeIntArray")]
    public class RemoveIntArrayFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)]
        public virtual byte[] Key { get; set; }
    }

    public partial class RemoveStringFunction : RemoveStringFunctionBase { }

    [Function("removeString")]
    public class RemoveStringFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)]
        public virtual byte[] Key { get; set; }
    }

    public partial class RemoveStringArrayFunction : RemoveStringArrayFunctionBase { }

    [Function("removeStringArray")]
    public class RemoveStringArrayFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)]
        public virtual byte[] Key { get; set; }
    }

    public partial class RemoveUintFunction : RemoveUintFunctionBase { }

    [Function("removeUint")]
    public class RemoveUintFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)]
        public virtual byte[] Key { get; set; }
    }

    public partial class RemoveUint1Function : RemoveUint1FunctionBase { }

    [Function("removeUint")]
    public class RemoveUint1FunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "setKey", 1)]
        public virtual byte[] SetKey { get; set; }
        [Parameter("uint256", "value", 2)]
        public virtual BigInteger Value { get; set; }
    }

    public partial class RemoveUintArrayFunction : RemoveUintArrayFunctionBase { }

    [Function("removeUintArray")]
    public class RemoveUintArrayFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)]
        public virtual byte[] Key { get; set; }
    }

    public partial class RoleStoreFunction : RoleStoreFunctionBase { }

    [Function("roleStore", "address")]
    public class RoleStoreFunctionBase : FunctionMessage
    {

    }

    public partial class SetAddressFunction : SetAddressFunctionBase { }

    [Function("setAddress", "address")]
    public class SetAddressFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)]
        public virtual byte[] Key { get; set; }
        [Parameter("address", "value", 2)]
        public virtual string Value { get; set; }
    }

    public partial class SetAddressArrayFunction : SetAddressArrayFunctionBase { }

    [Function("setAddressArray")]
    public class SetAddressArrayFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)]
        public virtual byte[] Key { get; set; }
        [Parameter("address[]", "value", 2)]
        public virtual List<string> Value { get; set; }
    }

    public partial class SetBoolFunction : SetBoolFunctionBase { }

    [Function("setBool", "bool")]
    public class SetBoolFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)]
        public virtual byte[] Key { get; set; }
        [Parameter("bool", "value", 2)]
        public virtual bool Value { get; set; }
    }

    public partial class SetBoolArrayFunction : SetBoolArrayFunctionBase { }

    [Function("setBoolArray")]
    public class SetBoolArrayFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)]
        public virtual byte[] Key { get; set; }
        [Parameter("bool[]", "value", 2)]
        public virtual List<bool> Value { get; set; }
    }

    public partial class SetBytes32Function : SetBytes32FunctionBase { }

    [Function("setBytes32", "bytes32")]
    public class SetBytes32FunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)]
        public virtual byte[] Key { get; set; }
        [Parameter("bytes32", "value", 2)]
        public virtual byte[] Value { get; set; }
    }

    public partial class SetBytes32ArrayFunction : SetBytes32ArrayFunctionBase { }

    [Function("setBytes32Array")]
    public class SetBytes32ArrayFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)]
        public virtual byte[] Key { get; set; }
        [Parameter("bytes32[]", "value", 2)]
        public virtual List<byte[]> Value { get; set; }
    }

    public partial class SetIntFunction : SetIntFunctionBase { }

    [Function("setInt", "int256")]
    public class SetIntFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)]
        public virtual byte[] Key { get; set; }
        [Parameter("int256", "value", 2)]
        public virtual BigInteger Value { get; set; }
    }

    public partial class SetIntArrayFunction : SetIntArrayFunctionBase { }

    [Function("setIntArray")]
    public class SetIntArrayFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)]
        public virtual byte[] Key { get; set; }
        [Parameter("int256[]", "value", 2)]
        public virtual List<BigInteger> Value { get; set; }
    }

    public partial class SetStringFunction : SetStringFunctionBase { }

    [Function("setString", "string")]
    public class SetStringFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)]
        public virtual byte[] Key { get; set; }
        [Parameter("string", "value", 2)]
        public virtual string Value { get; set; }
    }

    public partial class SetStringArrayFunction : SetStringArrayFunctionBase { }

    [Function("setStringArray")]
    public class SetStringArrayFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)]
        public virtual byte[] Key { get; set; }
        [Parameter("string[]", "value", 2)]
        public virtual List<string> Value { get; set; }
    }

    public partial class SetUintFunction : SetUintFunctionBase { }

    [Function("setUint", "uint256")]
    public class SetUintFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)]
        public virtual byte[] Key { get; set; }
        [Parameter("uint256", "value", 2)]
        public virtual BigInteger Value { get; set; }
    }

    public partial class SetUintArrayFunction : SetUintArrayFunctionBase { }

    [Function("setUintArray")]
    public class SetUintArrayFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)]
        public virtual byte[] Key { get; set; }
        [Parameter("uint256[]", "value", 2)]
        public virtual List<BigInteger> Value { get; set; }
    }

    public partial class StringArrayValuesFunction : StringArrayValuesFunctionBase { }

    [Function("stringArrayValues", "string")]
    public class StringArrayValuesFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "", 1)]
        public virtual byte[] ReturnValue1 { get; set; }
        [Parameter("uint256", "", 2)]
        public virtual BigInteger ReturnValue2 { get; set; }
    }

    public partial class StringValuesFunction : StringValuesFunctionBase { }

    [Function("stringValues", "string")]
    public class StringValuesFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "", 1)]
        public virtual byte[] ReturnValue1 { get; set; }
    }

    public partial class UintArrayValuesFunction : UintArrayValuesFunctionBase { }

    [Function("uintArrayValues", "uint256")]
    public class UintArrayValuesFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "", 1)]
        public virtual byte[] ReturnValue1 { get; set; }
        [Parameter("uint256", "", 2)]
        public virtual BigInteger ReturnValue2 { get; set; }
    }

    public partial class UintValuesFunction : UintValuesFunctionBase { }

    [Function("uintValues", "uint256")]
    public class UintValuesFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "", 1)]
        public virtual byte[] ReturnValue1 { get; set; }
    }

    public partial class UnauthorizedError : UnauthorizedErrorBase { }

    [Error("Unauthorized")]
    public class UnauthorizedErrorBase : IErrorDTO
    {
        [Parameter("address", "msgSender", 1)]
        public virtual string MsgSender { get; set; }
        [Parameter("string", "role", 2)]
        public virtual string Role { get; set; }
    }







    public partial class AddressArrayValuesOutputDTO : AddressArrayValuesOutputDTOBase { }

    [FunctionOutput]
    public class AddressArrayValuesOutputDTOBase : IFunctionOutputDTO 
    {
        [Parameter("address", "", 1)]
        public virtual string ReturnValue1 { get; set; }
    }

    public partial class AddressValuesOutputDTO : AddressValuesOutputDTOBase { }

    [FunctionOutput]
    public class AddressValuesOutputDTOBase : IFunctionOutputDTO 
    {
        [Parameter("address", "", 1)]
        public virtual string ReturnValue1 { get; set; }
    }









    public partial class BoolArrayValuesOutputDTO : BoolArrayValuesOutputDTOBase { }

    [FunctionOutput]
    public class BoolArrayValuesOutputDTOBase : IFunctionOutputDTO 
    {
        [Parameter("bool", "", 1)]
        public virtual bool ReturnValue1 { get; set; }
    }

    public partial class BoolValuesOutputDTO : BoolValuesOutputDTOBase { }

    [FunctionOutput]
    public class BoolValuesOutputDTOBase : IFunctionOutputDTO 
    {
        [Parameter("bool", "", 1)]
        public virtual bool ReturnValue1 { get; set; }
    }

    public partial class Bytes32ArrayValuesOutputDTO : Bytes32ArrayValuesOutputDTOBase { }

    [FunctionOutput]
    public class Bytes32ArrayValuesOutputDTOBase : IFunctionOutputDTO 
    {
        [Parameter("bytes32", "", 1)]
        public virtual byte[] ReturnValue1 { get; set; }
    }

    public partial class Bytes32ValuesOutputDTO : Bytes32ValuesOutputDTOBase { }

    [FunctionOutput]
    public class Bytes32ValuesOutputDTOBase : IFunctionOutputDTO 
    {
        [Parameter("bytes32", "", 1)]
        public virtual byte[] ReturnValue1 { get; set; }
    }

    public partial class ContainsAddressOutputDTO : ContainsAddressOutputDTOBase { }

    [FunctionOutput]
    public class ContainsAddressOutputDTOBase : IFunctionOutputDTO 
    {
        [Parameter("bool", "", 1)]
        public virtual bool ReturnValue1 { get; set; }
    }

    public partial class ContainsBytes32OutputDTO : ContainsBytes32OutputDTOBase { }

    [FunctionOutput]
    public class ContainsBytes32OutputDTOBase : IFunctionOutputDTO 
    {
        [Parameter("bool", "", 1)]
        public virtual bool ReturnValue1 { get; set; }
    }

    public partial class ContainsUintOutputDTO : ContainsUintOutputDTOBase { }

    [FunctionOutput]
    public class ContainsUintOutputDTOBase : IFunctionOutputDTO 
    {
        [Parameter("bool", "", 1)]
        public virtual bool ReturnValue1 { get; set; }
    }





    public partial class GetAddressOutputDTO : GetAddressOutputDTOBase { }

    [FunctionOutput]
    public class GetAddressOutputDTOBase : IFunctionOutputDTO 
    {
        [Parameter("address", "", 1)]
        public virtual string ReturnValue1 { get; set; }
    }

    public partial class GetAddressArrayOutputDTO : GetAddressArrayOutputDTOBase { }

    [FunctionOutput]
    public class GetAddressArrayOutputDTOBase : IFunctionOutputDTO 
    {
        [Parameter("address[]", "", 1)]
        public virtual List<string> ReturnValue1 { get; set; }
    }

    public partial class GetAddressCountOutputDTO : GetAddressCountOutputDTOBase { }

    [FunctionOutput]
    public class GetAddressCountOutputDTOBase : IFunctionOutputDTO 
    {
        [Parameter("uint256", "", 1)]
        public virtual BigInteger ReturnValue1 { get; set; }
    }

    public partial class GetAddressValuesAtOutputDTO : GetAddressValuesAtOutputDTOBase { }

    [FunctionOutput]
    public class GetAddressValuesAtOutputDTOBase : IFunctionOutputDTO 
    {
        [Parameter("address[]", "", 1)]
        public virtual List<string> ReturnValue1 { get; set; }
    }

    public partial class GetBoolOutputDTO : GetBoolOutputDTOBase { }

    [FunctionOutput]
    public class GetBoolOutputDTOBase : IFunctionOutputDTO 
    {
        [Parameter("bool", "", 1)]
        public virtual bool ReturnValue1 { get; set; }
    }

    public partial class GetBoolArrayOutputDTO : GetBoolArrayOutputDTOBase { }

    [FunctionOutput]
    public class GetBoolArrayOutputDTOBase : IFunctionOutputDTO 
    {
        [Parameter("bool[]", "", 1)]
        public virtual List<bool> ReturnValue1 { get; set; }
    }

    public partial class GetBytes32OutputDTO : GetBytes32OutputDTOBase { }

    [FunctionOutput]
    public class GetBytes32OutputDTOBase : IFunctionOutputDTO 
    {
        [Parameter("bytes32", "", 1)]
        public virtual byte[] ReturnValue1 { get; set; }
    }

    public partial class GetBytes32ArrayOutputDTO : GetBytes32ArrayOutputDTOBase { }

    [FunctionOutput]
    public class GetBytes32ArrayOutputDTOBase : IFunctionOutputDTO 
    {
        [Parameter("bytes32[]", "", 1)]
        public virtual List<byte[]> ReturnValue1 { get; set; }
    }

    public partial class GetBytes32CountOutputDTO : GetBytes32CountOutputDTOBase { }

    [FunctionOutput]
    public class GetBytes32CountOutputDTOBase : IFunctionOutputDTO 
    {
        [Parameter("uint256", "", 1)]
        public virtual BigInteger ReturnValue1 { get; set; }
    }

    public partial class GetBytes32ValuesAtOutputDTO : GetBytes32ValuesAtOutputDTOBase { }

    [FunctionOutput]
    public class GetBytes32ValuesAtOutputDTOBase : IFunctionOutputDTO 
    {
        [Parameter("bytes32[]", "", 1)]
        public virtual List<byte[]> ReturnValue1 { get; set; }
    }

    public partial class GetIntOutputDTO : GetIntOutputDTOBase { }

    [FunctionOutput]
    public class GetIntOutputDTOBase : IFunctionOutputDTO 
    {
        [Parameter("int256", "", 1)]
        public virtual BigInteger ReturnValue1 { get; set; }
    }

    public partial class GetIntArrayOutputDTO : GetIntArrayOutputDTOBase { }

    [FunctionOutput]
    public class GetIntArrayOutputDTOBase : IFunctionOutputDTO 
    {
        [Parameter("int256[]", "", 1)]
        public virtual List<BigInteger> ReturnValue1 { get; set; }
    }

    public partial class GetStringOutputDTO : GetStringOutputDTOBase { }

    [FunctionOutput]
    public class GetStringOutputDTOBase : IFunctionOutputDTO 
    {
        [Parameter("string", "", 1)]
        public virtual string ReturnValue1 { get; set; }
    }

    public partial class GetStringArrayOutputDTO : GetStringArrayOutputDTOBase { }

    [FunctionOutput]
    public class GetStringArrayOutputDTOBase : IFunctionOutputDTO 
    {
        [Parameter("string[]", "", 1)]
        public virtual List<string> ReturnValue1 { get; set; }
    }

    public partial class GetUintOutputDTO : GetUintOutputDTOBase { }

    [FunctionOutput]
    public class GetUintOutputDTOBase : IFunctionOutputDTO 
    {
        [Parameter("uint256", "", 1)]
        public virtual BigInteger ReturnValue1 { get; set; }
    }

    public partial class GetUintArrayOutputDTO : GetUintArrayOutputDTOBase { }

    [FunctionOutput]
    public class GetUintArrayOutputDTOBase : IFunctionOutputDTO 
    {
        [Parameter("uint256[]", "", 1)]
        public virtual List<BigInteger> ReturnValue1 { get; set; }
    }

    public partial class GetUintCountOutputDTO : GetUintCountOutputDTOBase { }

    [FunctionOutput]
    public class GetUintCountOutputDTOBase : IFunctionOutputDTO 
    {
        [Parameter("uint256", "", 1)]
        public virtual BigInteger ReturnValue1 { get; set; }
    }

    public partial class GetUintValuesAtOutputDTO : GetUintValuesAtOutputDTOBase { }

    [FunctionOutput]
    public class GetUintValuesAtOutputDTOBase : IFunctionOutputDTO 
    {
        [Parameter("uint256[]", "", 1)]
        public virtual List<BigInteger> ReturnValue1 { get; set; }
    }





    public partial class IntArrayValuesOutputDTO : IntArrayValuesOutputDTOBase { }

    [FunctionOutput]
    public class IntArrayValuesOutputDTOBase : IFunctionOutputDTO 
    {
        [Parameter("int256", "", 1)]
        public virtual BigInteger ReturnValue1 { get; set; }
    }

    public partial class IntValuesOutputDTO : IntValuesOutputDTOBase { }

    [FunctionOutput]
    public class IntValuesOutputDTOBase : IFunctionOutputDTO 
    {
        [Parameter("int256", "", 1)]
        public virtual BigInteger ReturnValue1 { get; set; }
    }































    public partial class RoleStoreOutputDTO : RoleStoreOutputDTOBase { }

    [FunctionOutput]
    public class RoleStoreOutputDTOBase : IFunctionOutputDTO 
    {
        [Parameter("address", "", 1)]
        public virtual string ReturnValue1 { get; set; }
    }

























    public partial class StringArrayValuesOutputDTO : StringArrayValuesOutputDTOBase { }

    [FunctionOutput]
    public class StringArrayValuesOutputDTOBase : IFunctionOutputDTO 
    {
        [Parameter("string", "", 1)]
        public virtual string ReturnValue1 { get; set; }
    }

    public partial class StringValuesOutputDTO : StringValuesOutputDTOBase { }

    [FunctionOutput]
    public class StringValuesOutputDTOBase : IFunctionOutputDTO 
    {
        [Parameter("string", "", 1)]
        public virtual string ReturnValue1 { get; set; }
    }

    public partial class UintArrayValuesOutputDTO : UintArrayValuesOutputDTOBase { }

    [FunctionOutput]
    public class UintArrayValuesOutputDTOBase : IFunctionOutputDTO 
    {
        [Parameter("uint256", "", 1)]
        public virtual BigInteger ReturnValue1 { get; set; }
    }

    public partial class UintValuesOutputDTO : UintValuesOutputDTOBase { }

    [FunctionOutput]
    public class UintValuesOutputDTOBase : IFunctionOutputDTO 
    {
        [Parameter("uint256", "", 1)]
        public virtual BigInteger ReturnValue1 { get; set; }
    }
}
