How to declare a delegate that can take an enum which is not known until runtime?

I have a client application that uses classes (and enums) from an external dll which is loaded at runtime and reflected. I know what methods I am expecting to find in the dll and what I am expecting its enums to be called.

I would like to create a delegate that I can use in the client application and which is created from the reflected method at runtime. This approach works when the delegate just has "standard" types, but how can I get this to work if the dll method takes an enum? I can't declare the enum in the delegate as an object since it's a value type, trying the Enum or int does not seem to work either. Is there a way around this? Any help gratefully received!

// e.g. external code
namespace test2 
{
    public static class test2
    {
        public static int calc(int a, int b, testEnum c)
        {
            if (c == testEnum.add) return a + b;
            else return a - b;
        }

        public static int add(int a, int b)
        {
            return a + b;
        }
    }

    public enum testEnum
    {
        add, subtract
    }
}

// my client code
namespace test1
{
    public class TestClient
    {
        private static Assembly _assembly;

        public static void SetUp()
        {
            const string externalDll = ".../test2.dll";

            Assembly assembly = Assembly.LoadFrom(externalDll);
            AppDomain.CurrentDomain.Load(assembly.GetName());
            _assembly = assembly;
        }

        private delegate int _add(int a, int b);
        private _add add;

        private delegate int _calc(int a, int b, ??? c); // nothing works here
        private _calc calc;

        public void Run()
        {
            SetUp();
            add = GetExpectedFunction<_add>("add");
            int three = add(1, 2); // OK

            calc = GetExpectedFunction<_calc>("calc"); // not OK

            // intended usage
            var reflectedEnum = ReflectMe("testEnum", "add");
            int threeAgain = calc(1, 2, reflectedEnum); 
        }

        public static T GetExpectedFunction<T>(string functionName) where T : class
        {
            try
            {
                if (!typeof(T).IsSubclassOf(typeof(Delegate))) throw new ApplicationException("GetExpectedFunction must return a delegate!");
                var foundMethod = _assembly.GetType("test2.test2").GetMethod(functionName, BindingFlags.Public | BindingFlags.Static);
                return (T)(object)Delegate.CreateDelegate(typeof(T), foundMethod);  
            }
            catch (Exception e)
            {
                // "Error binding to target method!"
            }
        }
    }
}