ambiguous use of init with default values

I have class that have two similar looking initializers:

public init(
        contentInsets: MyInsets = .init(vertical: .level0, horizontal: .level6),
        midToLeftSpacing: CGFloat = 0,
        rightToMidSpacing: CGFloat = 0
)

public init(
        contentInsets: MyInsets = .init(vertical: .level0, horizontal: .level6),
        midToLeftSpacing: MyInsetLevel = .level0,
        rightToMidSpacing: MyInsetLevel = .level0
)

Now i run into problem, looks like when i trying to call initializer compiler can't figure out which one to chose:

init(
vertical: .level0,
left: .level22,
right: .level0
)

Gives error - Ambiguous use of 'init'

It could be easily fixed with modifying initializer or adding next argument with default value, but it doesn't look right, is there any other way to specify init method called?

Your example doesn't match your code (there is no init(vertical:left:right) defined), so I'm going to try to generalize this problem a bit with a full example that avoids the extra types. I'll just use Double and Int here.

Imagine a struct X that internally stores three Doubles:

struct X {
    var x: Double
    var y: Double
    var z: Double
    init(x: Double = 0, y: Double = 0, z: Double = 0) {
        self.x = x
        self.y = y
        self.z = z
    }
}

You also want to be able to pass three Ints instead, but all three must either be Doubles or Ints, and you want default values. Every use of default values is just a shorthand for an extra method with fewer parameters. To avoid conflicts, you need to include at least one of the parameters as non-default:

extension X {
    init(x: Int, y: Int = 0, z: Int = 0) {
        self.init(x: Double(x), y: Double(y), z: Double(z))
    }
    init(y: Int, z: Int = 0) { self.init(x: 0, y: y, z: z) }
    init(z: Int) { self.init(x: 0, y: 0, z: z) }
}

Now, every combination is legal, but there are no ambiguities.

This is nice when there's just one extra way to call the init. But maybe you want there to be many. Then a protocol is useful. For example, this approach allows either Int or Double for every parameter:

protocol XParameter {
    var xParameterValue: Double { get }
}

extension Double: XParameter {
    var xParameterValue: Double { self }
}

extension Int: XParameter {
    var xParameterValue: Double { Double(self) }
}

struct X {
    var x: Double
    var y: Double
    var z: Double
    init(x: some XParameter = 0, y: some XParameter = 0, z: some XParameter = 0) {
        self.x = x.xParameterValue
        self.y = y.xParameterValue
        self.z = z.xParameterValue
    }
}