public record IdentifierSheet
{
    public required string Identifier { get; init; }
    public Security SecurityType { get; init; }
    public required string Symbol { get; init; }
    public Exchange Exchange { get; init; }
    public string? Name { get; init; }
}

public record FutureIdentifierSheet : IdentifierSheet
{
    public string Underlying { get; init; } = string.Empty;

    public required DateTime ExpirationDate { get; init; }

    public required string ProductCode { get; init; }

    public required DateTime YearMonth { get; init; }
}

private class SecurityTypeDiscriminatorConvention : IDiscriminatorConvention
{
    public string ElementName => nameof(IdentifierSheet.SecurityType);

    public Type GetActualType(IBsonReader bsonReader, Type nominalType)
    {
        var bookmark = bsonReader.GetBookmark();

        bsonReader.ReadStartDocument();
        var actualType = typeof(IdentifierSheet);

        while (bsonReader.ReadBsonType() != BsonType.EndOfDocument)
        {
            string? name = bsonReader.ReadName();
            if (name == ElementName)
            {
                var enumValue = (SecurityType.Security)(object)bsonReader.ReadInt32();
                actualType = enumValue switch
                {
                    SecurityType.Security.Future => typeof(FutureIdentifierSheet),
                    SecurityType.Security.Option => typeof(OptionIdentifierSheet),
                    _ => actualType
                };
                break;
            }

            bsonReader.SkipValue();
        }

        bsonReader.ReturnToBookmark(bookmark);
        return actualType;
    }

    public BsonValue GetDiscriminator(Type nominalType, Type actualType)
    {
        if (actualType == typeof(FutureIdentifierSheet))
            return (int)SecurityType.Security.Future;
        if (actualType == typeof(OptionIdentifierSheet))
            return (int)SecurityType.Security.Option;

        return (int)SecurityType.Security.NoSecurity; // fallback or base
    }
}