Resolved: Custom JSON decoding: decode an array of different objects in several distinct arrays

{
  "zones": [
    {
      "name": "zoneA",
      "blocks": [
        // an array of objects of type ElementA
      ]
    },
    {
      "name": "zoneB",
      "blocks": [
        // an array of objects of type ElementB
      ]
    },
    {
      "name": "zoneC",
      "blocks": [
        // an array of objects of type ElementC
      ]
    },
    {
      "name": "zoneD",
      "blocks": [
        // an array of objects of type ElementD
      ]
    }
  ]
}

struct Root {
    let elementsA: [ElementA]
    let elementsB: [ElementB]
    let elementsC: [ElementC]
    let elementsD: [ElementD]
}

let jsonString = """
{
  "zones": [
    {
      "name": "zoneA",
      "blocks": [
        {"name": "Foo"}
      ]
    },
    {
      "name": "zoneB",
      "blocks": [
        {"street":"Broadway", "city":"New York"}
      ]
    },
    {
      "name": "zoneC",
      "blocks": [
        {"email": "foo@bar.com"}
      ]
    },
    {
      "name": "zoneD",
      "blocks": [
        {"phone": "555-01234"}
      ]
    }
  ]
}
"""

struct ElementA : Decodable { let name: String }
struct ElementB : Decodable { let street, city: String }
struct ElementC : Decodable { let email: String }
struct ElementD : Decodable { let phone: String }

struct Root : Decodable {
    var elementsA = [ElementA]()
    var elementsB = [ElementB]()
    var elementsC = [ElementC]()
    var elementsD = [ElementD]()
    
    private enum CodingKeys: String, CodingKey { case zones }
    private enum ZoneCodingKeys: String, CodingKey { case name, blocks }
    
    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        var zonesContainer = try container.nestedUnkeyedContainer(forKey: .zones)
        while !zonesContainer.isAtEnd {
            let item = try zonesContainer.nestedContainer(keyedBy: ZoneCodingKeys.self)
            let name = try item.decode(String.self, forKey: .name)
            switch name {
                case "zoneA": elementsA = try item.decode([ElementA].self, forKey: .blocks)
                case "zoneB": elementsB = try item.decode([ElementB].self, forKey: .blocks)
                case "zoneC": elementsC = try item.decode([ElementC].self, forKey: .blocks)
                case "zoneD": elementsD = try item.decode([ElementD].self, forKey: .blocks)
                default: throw DecodingError.dataCorruptedError(forKey: .blocks, in: item, debugDescription: "Name \(name) is not supported")
            }
        }
    }
}

do {
    let result = try JSONDecoder().decode(Root.self, from: Data(jsonString.utf8))
    print(result)
} catch {
    print(error)
}