Parameter.cs

namespace _;
public class Parameter<T> //: IParameter - unnecesary
{
    private string? stringValue;
    private T value;

    public bool IsValid { get; private set; }

    public static bool TryParse(string value, out Parameter<T> result)
    {
        return TryParse(value, null!, out result);
    }

    public static bool TryParse(string value, IFormatProvider provider, out Parameter<T> result)
    {
        result = new Parameter<T>
        {
            stringValue = value
        };

        var success = TryParseParameter(value, provider, out var resultValue);
        if (!success)
        {
            return true;
        }

        result.value = resultValue;
        result.IsValid = true;
        return true;
    }

    private static bool TryParseParameter(string value, IFormatProvider provider, out T result)
    {
        var success = false;
        result = default;

        if (typeof(T) == typeof(bool))
        {
            success = bool.TryParse(value, out var parsedValue);
            result = (T)(object)parsedValue;
            return success;
        }

        if (typeof(T).IsEnum)
        {
            success = Enum.TryParse(typeof(T), value, true, out var parsedValue);
            success = success && Enum.IsDefined(typeof(T), parsedValue!);
            if (success)
            {
                result = (T)parsedValue;
            }

            return success;
        }

        if (typeof(T) == typeof(DateTime))
        {
            success = DateTime.TryParse(value, provider, out var parsedValue);
            result = (T)(object)parsedValue;
            return success;
        }

        return success;
    }

    public static implicit operator T(Parameter<T> p)
    {
        return p.value;
    }

    public override string? ToString()
    {
        return stringValue;
    }
}

ParameterSchemaTransformer.cs

namespace _;
public class ParameterSchemaTransformer : IOpenApiSchemaTransformer
{
    public Task TransformAsync(OpenApiSchema schema, OpenApiSchemaTransformerContext context,
        CancellationToken cancellationToken)
    {
        var type = context.JsonTypeInfo.Type;
        if (!type.IsGenericType || type.GetGenericTypeDefinition() != typeof(Parameter<>))
        {
            return Task.CompletedTask;
        }

        var parameterType = type.GetGenericArguments().FirstOrDefault();
        if (parameterType != null && parameterType.IsEnum)
        {
            schema.Type = "string";
            schema.Enum = Enum.GetNames(parameterType).Select(IOpenApiAny (i) => new OpenApiString(i)).ToList();
        }

        if (parameterType == typeof(bool))
        {
            schema.Type = "boolean";
        }

        if (parameterType == typeof(DateTime))
        {
            schema.Type = "string";
            schema.Format = "date-time";
        }

        return Task.CompletedTask;
    }
}

Example usage:

app.MapGet("/", ([FromQuery] Parameter<MyEnum> param) => 
{
   MyEnum enumValue = param;
});

Where does the IParameter interface come from?

Where does the IParameter interface come from?

From former implementation - shouldn't be necessary