AutoMapper:mapeo a configuradores privados contenidos en objetos anidados definidos por interfaces

Solución para AutoMapper:la asignación a configuradores privados contenidos en objetos anidados definidos por interfaces
se proporciona a continuación:

Creé una aplicación de consola que refleja el problema que tengo.
Quiero:

1. Poder mapear propiedades de solo lectura (aquellas con configuradores privados)
2. Haga que esas propiedades estén dentro de objetos anidados
3. Haga que esos objetos anidados se declaren como una interfaz dentro de su clase principal

Parece que no puedo obtener todo lo anterior al mismo tiempo. Aquí está el código de ejemplo:

using AutoMapper;
using System;

namespace ConsoleApp5
{
    class Program
    {
        static void Main(string[] args)
        {
            var dbCvg = new DbCoverage("123", "b", "blue", new DbChild(5, 9));

            var config = new MapperConfiguration(cfg => {
                cfg.CreateMap<IDbCoverage, Coverage>();
                cfg.CreateMap<IDbChild, IChild>();
            });

            var mapper = new Mapper(config);

            var destClass = mapper.Map<Coverage>(dbCvg);

            Console.WriteLine(destClass.ExternalMemberId);
            Console.WriteLine(destClass.CoverageCode);
            Console.WriteLine(destClass.ReadOnlyDesc);

            Console.WriteLine(destClass.Child.someValue);
            Console.WriteLine(destClass.Child.readOnlyValue);
        }
    }

    public interface IDbCoverage
    {
        string ExternalMemberId { get; set; }
        string CoverageCode { get; set; }
        string ReadOnlyDesc { get; }
        IDbChild Child { get; set; }
    }


    public interface IDbChild
    {
        int someValue { get; set; }
        int readOnlyValue { get; }
    }

    public interface ICoverage
    {
        string ExternalMemberId { get; set; }
        string CoverageCode { get; set; }
        string ReadOnlyDesc { get; }
        IChild Child { get; set; }
    }

    public interface IChild
    {
        int someValue { get; set; }
        int readOnlyValue { get; }
    }

    public class Coverage : ICoverage
    {
        public string ExternalMemberId { get; set; }
        public string CoverageCode { get; set; }
        public string ReadOnlyDesc { get; private set; }
        public IChild Child { get; set; } 
    }

    public class Child : IChild
    {
        public int someValue { get; set; }
        public int readOnlyValue { get; private set; }
    }

    public class DbCoverage : IDbCoverage
    {
        public string ExternalMemberId { get; set; }
        public string CoverageCode { get; set; }
        public string ReadOnlyDesc { get; private set; }
        public IDbChild Child { get; set; }

        public DbCoverage(string Id, string code, string desc, IDbChild child)
        {
            ExternalMemberId = Id;
            CoverageCode = code;
            ReadOnlyDesc = desc;
            Child = child;
        }
    }

    public class DbChild : IDbChild
    {
        public int someValue { get; set; }
        public int readOnlyValue { get; private set; }

        public DbChild(int smVal, int roVal)
        {
            someValue = smVal;
            readOnlyValue = roVal;
        }
    }
}

Cuando esto se ejecuta, podemos ver que la última línea de salida es 0 en lugar de 9 porque el 9 no se asignó.
Esto se debe al hecho de que la asignación es de IDbChild -> IChild e IChild no tiene un setter para esa propiedad.

Sin embargo, si intento mapear IDbChild -> Child, obtengo un error de compilación que creo que se debe a que la propiedad Child anidada en el objeto Coverage está definida como una interfaz y, por lo tanto, quiere un mapeo IDbChild -> IChild.

¿Hay alguna forma de modificar la configuración de mapeo (pero no los objetos subyacentes ) para que esto funcione?

Mapear interfaces solo complica las cosas. Pero es posible.

    cfg.CreateMap<IDbChild, Child>();
    cfg.CreateMap<IDbChild, IChild>().As<Child>();

https://docs.automapper.org/en/latest/Mapping-heritance.html