Cannot serialize abstract list with Autorest generated client

Question

I've trying to call my controller in a behavior test. It works manually with Postman but not with a generated Autorest HttpClient. I've already created a specific JsonConverter in order to handle polymorphism. I've got the following response content

{
   "errors":{
      "command":[
         "The command field is required."
      ],
      "Sections[0].Title.0":[
         "Could not create an instance of type Section. Type is an interface or abstract class and cannot be instantiated. Path 'Sections[0].Title', line 7, position 14."
      ],
      "Sections[1].Kind.1":[
         "Could not create an instance of type Section. Type is an interface or abstract class and cannot be instantiated. Path 'Sections[1].Kind', line 14, position 13."
      ]
   },
   "type":"https://tools.ietf.org/html/rfc7231#section-6.5.1",
   "title":"One or more validation errors occurred.",
   "status":400,
   "traceId":"0HMI4P0JALIN1"
}

The models is a list of abstract class

public enum Kind
{
    CoverPage,
    PageBreak
}
public abstract record Section(Kind Kind, string Name);

public record PageBreak(string Name) : Section(Kind.PageBreak, Name)
{
    public string DisplayedString => _displayedString;
    private static string _displayedString = "............";
}
public record CoverPage(string Name, string Title, string SubTitleFirstLevel, string SubTitleSecondLevel) : Section(Kind.CoverPage, Name);

public record CreateTemplateCommand
{
    [Required]
    public string Name { get; init; }
    [Required]
    public IList<Section> Sections { get; init; }
}

The request content created by Autorest matches the json input in Postman

{
  "Name": "My Name",
  "Sections": [
    {
      "Title": "Blablabla",
      "SubTitleFirstLevel": "Sous-Titre 1",
      "SubTitleSecondLevel": "Sous-Titre 2",
      "Kind": "CoverPage",
      "Name": "Page de garde"
    },
    {
      "Kind": "PageBreak",
      "Name": "Saut de page"
    }
  ]
}

This is the generated Autorest code

public async Task<HttpOperationResponse> CreateTemplateWithHttpMessagesAsync(int enterpriseId, CreatePlaquetteTemplateCommand body, Dictionary<string, List<string>> customHeaders = null, CancellationToken cancellationToken = default(CancellationToken))
{
    if (body == null)
    {
        throw new ValidationException(ValidationRules.CannotBeNull, "body");
    }
    if (body != null)
    {
        body.Validate();
    }
    // Tracing
    bool _shouldTrace = ServiceClientTracing.IsEnabled;
    string _invocationId = null;
    if (_shouldTrace)
    {
        _invocationId = ServiceClientTracing.NextInvocationId.ToString();
        Dictionary<string, object> tracingParameters = new Dictionary<string, object>();
        tracingParameters.Add("enterpriseId", enterpriseId);
        tracingParameters.Add("body", body);
        tracingParameters.Add("cancellationToken", cancellationToken);
        ServiceClientTracing.Enter(_invocationId, this, "CreateTemplate", tracingParameters);
    }
    // Construct URL
    var _baseUrl = Client.BaseUri.AbsoluteUri;
    var _url = new System.Uri(new System.Uri(_baseUrl + (_baseUrl.EndsWith("/") ? "" : "/")), "api/plaquette/enterprises/{enterpriseId}/Templates").ToString();
    _url = _url.Replace("{enterpriseId}", System.Uri.EscapeDataString(Microsoft.Rest.Serialization.SafeJsonConvert.SerializeObject(enterpriseId, Client.SerializationSettings).Trim('"')));
    // Create HTTP transport objects
    var _httpRequest = new HttpRequestMessage();
    HttpResponseMessage _httpResponse = null;
    _httpRequest.Method = new HttpMethod("POST");
    _httpRequest.RequestUri = new System.Uri(_url);
    // Set Headers


    if (customHeaders != null)
    {
        foreach(var _header in customHeaders)
        {
            if (_httpRequest.Headers.Contains(_header.Key))
            {
                _httpRequest.Headers.Remove(_header.Key);
            }
            _httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
        }
    }

    // Serialize Request
    string _requestContent = null;
    if(body != null)
    {
        _requestContent = Microsoft.Rest.Serialization.SafeJsonConvert.SerializeObject(body, Client.SerializationSettings);
        _httpRequest.Content = new StringContent(_requestContent, System.Text.Encoding.UTF8);
        _httpRequest.Content.Headers.ContentType =System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json-patch+json; charset=utf-8");
    }
    // Set Credentials
    if (Client.Credentials != null)
    {
        cancellationToken.ThrowIfCancellationRequested();
        await Client.Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
    }
    // Send Request
    if (_shouldTrace)
    {
        ServiceClientTracing.SendRequest(_invocationId, _httpRequest);
    }
    cancellationToken.ThrowIfCancellationRequested();
    _httpResponse = await Client.HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
    if (_shouldTrace)
    {
        ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse);
    }
    HttpStatusCode _statusCode = _httpResponse.StatusCode;
    cancellationToken.ThrowIfCancellationRequested();
    string _responseContent = null;
    if ((int)_statusCode != 200 && (int)_statusCode != 201 && (int)_statusCode != 204)
    {
        var ex = new HttpOperationException(string.Format("Operation returned an invalid status code '{0}'", _statusCode));
        if (_httpResponse.Content != null) {
            _responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
        }
        else {
            _responseContent = string.Empty;
        }
        ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent);
        ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent);
        if (_shouldTrace)
        {
            ServiceClientTracing.Error(_invocationId, ex);
        }
        _httpRequest.Dispose();
        if (_httpResponse != null)
        {
            _httpResponse.Dispose();
        }
        throw ex;
    }
    // Create Result
    var _result = new HttpOperationResponse();
    _result.Request = _httpRequest;
    _result.Response = _httpResponse;
    if (_shouldTrace)
    {
        ServiceClientTracing.Exit(_invocationId, _result);
    }
    return _result;
}