Due to situations where, for example, "double/sequential" rendering of Go Templates occurs - see the example below:

templates:
  release:
    installedTemplate: '{{`{{ .Values | get "config" | get .Release.Name (dict) | get "installed" false }}`}}'
    waitTemplate: '{{`{{ .Values | get "config" | get $.Release.Name (dict) | get "wait" false }}`}}'

we are forced to accept the fact that the resulting rendered value will always be !!str. In case we want to template installed, wait, or other values that expect !!bool, we have to introduce various "workarounds" like installedTemplate and waitTemplate, which serve as a "patch" for the problem. They expect !!str, which is then converted to !!bool, and based on that, their counterparts (without the Template suffix) are set.

Since this solution is by no means robust, clean, or elegant, and also requires manually creating these "helper" keys, not all necessary keys are configurable in this way. Therefore, I suggest that all keys expecting !!bool automatically accept !!str variants as well, meaning true or "true", false or "false". Any necessary conversion would be handled by Helmfile behind the scenes. What do you think about it? This way, we would get rid of all the somethingTemplate keys, and the result would be the same... For easy conversion, I propose a private method that accepts !!bool or its !!str variant and always returns a bool - here's my proposal:

import (
    "fmt"
    "strconv" // We use the method: strconv.ParseBool(string) (bool, error)
)

func parseToBoolean(value interface{}) (bool, error) {
    switch v := value.(type) {
    case bool:
        return v, nil
    case string:
        return strconv.ParseBool(v)
    default:
        return false, fmt.Errorf("unsupported type: %T", v)
    }
}

// Example of usage
func main() {
    value := "true"
    booleanValue, err := parseToBoolean(value)
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println(booleanValue) // Output: true
    }
}