public class CalculatedSpeedCalculatedField : CalculatedField
{
    private RequiredField distance;
    private RequiredField time;

    public CalculatedSpeedCalculatedField()
    {
        this.Name = "CustomCalculatedSpeed";
        this.DisplayName = "Custom Calculated Speed";
        this.distance = RequiredField.ForProperty("distance");
        this.time = RequiredField.ForProperty("time");
    }

    protected override IEnumerable<RequiredField> RequiredFields()
    {
        return new List<RequiredField>
        {
            this.distance,
            this.time,
        };
    }

    protected override AggregateValue CalculateValue(IAggregateValues aggregateValues)
    {
        var aggregateDistance = aggregateValues.GetAggregateValue(this.distance);
        var aggregateTime = aggregateValues.GetAggregateValue(this.time);

        if (aggregateDistance.IsError())
        {
            return aggregateDistance;
        }
        else if (aggregateTime.IsError())
        {
            return aggregateTime;
        }

        double dist = aggregateDistance.ConvertOrDefault<double>();
        double tim = aggregateTime.ConvertOrDefault<double>();
        return new DoubleAggregateValue(dist / tim);
    }
}

    [TypeConverter(typeof(PitchTypeConverter))]
    public sealed record Pitch(double MinValue, double MaxValue) : IParsable<Pitch>
    {
        public static readonly Pitch Empty = new(0, 0);

        public static Pitch Parse(string s, IFormatProvider provider) 
            => throw new NotImplementedException();
        public static bool TryParse([NotNullWhen(true)] string s, IFormatProvider provider, [MaybeNullWhen(false)] out Pitch result) 
            => throw new NotImplementedException();

        public override string ToString()
            => $"{MinValue}-{MaxValue}";
    }

  public sealed class PitchTypeConverter : TypeConverter
    {
        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType) 
            => base.CanConvertFrom(context, sourceType);

        public override bool CanConvertTo(ITypeDescriptorContext context, [NotNullWhen(true)] Type destinationType)
            => destinationType == typeof(string);

        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value) 
            => base.ConvertFrom(context, culture, value);

        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
            => value?.ToString() ?? Pitch.Empty.ToString();

        public override object CreateInstance(ITypeDescriptorContext context, IDictionary propertyValues) 
            => base.CreateInstance(context, propertyValues);

        public override bool GetCreateInstanceSupported(ITypeDescriptorContext context) 
            => base.GetCreateInstanceSupported(context);

        public override bool IsValid(ITypeDescriptorContext context, object value) 
            => base.IsValid(context, value);

        public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value, Attribute[] attributes) 
            => base.GetProperties(context, value, attributes);

        public override bool GetPropertiesSupported(ITypeDescriptorContext context) 
            => base.GetPropertiesSupported(context);

        public override StandardValuesCollection GetStandardValues(ITypeDescriptorContext context) 
            => base.GetStandardValues(context);

        public override bool GetStandardValuesExclusive(ITypeDescriptorContext context) 
            => base.GetStandardValuesExclusive(context);

        public override bool GetStandardValuesSupported(ITypeDescriptorContext context) 
            => base.GetStandardValuesSupported(context);
    }

    [Category("Conditions")]
        [Description("Sets the minimum/maximum allowed pitch limit.")]
        public Pitch PitchLimit
        {
            get => GetProperty(Pitch.Empty);
            set => SetProperty(value);
        }

        [Category("Conditions")]
        public bool RequiresDE
        {
            get => GetProperty<bool>();
            set => SetProperty(value);
        }