O objeto de retorno não é aquele declarado pela assinatura quando invocado por meio de reflexão

Embora você não tenha compartilhado suas implementações de ApiResult<T>or IPagedList<T>ou PagedList<T>, este parece ser um caso em que o padrão do conversor de fábrica seria necessário:

O padrão de fábrica é necessário para genéricos abertos porque o código para converter um objeto de e para uma string não é o mesmo para todos os tipos. Um conversor para um tipo genérico aberto ( List<T>,por exemplo) tem que criar um conversor para um tipo genérico fechado ( List<DateTime>, por exemplo) nos bastidores. O código deve ser escrito para manipular cada tipo genérico fechado que o conversor pode manipular.

Digamos que seus tipos sejam mais ou menos assim:

public abstract record ApiResult
{
    public static ApiResult<T> Create<T>(T result) => new ApiResult<T>(result);
}

public record ApiResult<T>(T Result) : ApiResult;

public interface IPagedList
{
    public IEnumerable Items { get; }
    public int PageNumber { get; }
    public int PageSize { get; }
    public int TotalItems { get; }
}

public interface IPagedList<out T> : IPagedList
{
    public new IEnumerable<T> Items { get; }
}

public class PagedList<T> : IPagedList<T>
{
    public IEnumerable<T> Items { get; }
    public int PageNumber { get; }
    public int PageSize { get; }
    public int TotalItems { get; }
    IEnumerable IPagedList.Items => Items;

    private protected PagedList(IEnumerable<T> items, int pageNumber, int pageSize, int totalItems) =>
        (this.Items, this.PageNumber, this.PageSize, this.TotalItems) = (items, pageNumber, pageSize, totalItems);

    public static IPagedList<T> Create(IEnumerable<T> items, int pageNumber, int pageSize, int totalItems) {
        //Ensure.That.IsNotNull(items);  // FIXED removed calls to undefined methods
        //Ensure.That.IsNotZeroOrNegative(pageNumber);
        //Ensure.That.IsNotZeroOrNegative(pageSize);
        return new PagedList<T>(items, pageNumber, pageSize, totalItems);
    }
}

Então você pode definir o seguinte conversor de fábrica e o conversor genérico interno da seguinte maneira:

public class PagedListConverter : JsonConverterFactory
{
    public override bool CanConvert(Type typeToConvert) => typeToConvert.IsPagedList();
    
    public override JsonConverter CreateConverter(Type typeToConvert, JsonSerializerOptions options) =>
        (JsonConverter)Activator.CreateInstance(typeof(PagedListConverter<>).MakeGenericType(typeToConvert.GetPagedListItemType()!))!;
}

public class PagedListConverter<T> : JsonConverter<IPagedList<T>>
{
    record DTO(IEnumerable<T> items, int pageNumber, int pageSize, int totalItems);

    public override bool CanConvert(Type typeToConvert) => typeToConvert == typeof(IPagedList<T>) || typeToConvert == typeof(PagedList<T>);

    public override IPagedList<T> Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) => 
        JsonSerializer.Deserialize<DTO>(ref reader, options) switch
        {
            var dto when dto is not null => PagedList<T>.Create(dto.items, dto.pageNumber, dto.pageSize, dto.totalItems),
            _ => PagedList<T>.Create(Enumerable.Empty<T>(), 0, 0, 0), // TODO: decide what to do in case a null value was encountered in the JSON
        };
        
    public override void Write(Utf8JsonWriter writer, IPagedList<T> value, JsonSerializerOptions options) =>
        JsonSerializer.Serialize(writer, new DTO(value.Items, value.PageNumber, value.PageSize, value.TotalItems), options);
}

public static class TypeExtensions
{
    public static IEnumerable<Type> GetInterfacesAndSelf(this Type type)
        => (type ?? throw new ArgumentNullException()).IsInterface ? new[] { type }.Concat(type.GetInterfaces()) : type.GetInterfaces();

    public static bool IsPagedList(this Type type) => type.GetPagedListItemType() != null;
    
    public static Type? GetPagedListItemType(this Type type) => 
        type.GetInterfacesAndSelf()
            .Where(t => t.IsGenericType && t.GetGenericTypeDefinition() == typeof(IPagedList<>))
            .Select(t => t.GetGenericArguments()[0])
            .SingleOrDefault();
}

Agora digamos que você tem alguma classe de item, por exemplo, como segue:

public class MyItem
{
    public string Name { get; set; }
    public decimal Price { get; set; }
}

Você poderá serializar e desserializar um PagedList<MyItem>ou IPagedList<MyItem>da seguinte maneira:

var result = ApiResult.Create(
    PagedList<MyItem>.Create([new () { Name = "name 1", Price = 101.1M }], 3, 1, 20)
);

var options = new JsonSerializerOptions
{
    Converters = { new PagedListConverter() },
    // Other options as required, e.g.
    WriteIndented = true,
    PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
};

var json = JsonSerializer.Serialize(result, options);

var newResult = JsonSerializer.Deserialize<ApiResult<IPagedList<MyItem>>>(json, options);

Notas:

• No conversor interno, em vez de escrever e ler cada propriedade manualmente, pode ser mais fácil mapear o tipo a ser serializado para algum DTO interno e, em seguida, serializar e desserializar o DTO.

• O padrão do conversor de fábrica pode não funcionar ao usar a geração de origem em um aplicativo AOT nativo . (Por exemplo Type.MakeGenericType(), e MethodInfo.MakeGenericMethod()não há garantia de que funcione em tal aplicativo.) Em vez disso, será necessário criar manualmente o conversor interno PagedListConverter<T>para todos os tipos T, por exemplo:

  var options = new JsonSerializerOptions
  {
      Converters = { 
          new PagedListConverter<MyItem>(),
          // Other PagedListConverter<T> converters as required
      },
      // Other options as required, e.g.
      WriteIndented = true,
      PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
  };
  

Demonstração do violino aqui .