Parsing string to time with unknown layout

I'm having a csv file, and want to read:

1. Header names
2. Fields types

So, I wrote the below:

package main

import (
    "encoding/csv"
    "fmt"
    "os"
    "log"
    "reflect"
    "strconv"
)

func main() {
    filePath := "./file.csv"
    headerNames := make(map[int]string)
    headerTypes := make(map[int]string)
    // Load a csv file.
    f, _ := os.Open(filePath)
    // Create a new reader.
    r := csv.NewReader(f)
    // Read first row only
    header, err := r.Read()
    checkError("Some other error occurred", err)

    // Add mapping: Column/property name --> record index
    for i, v := range header {
        headerNames[i] = v
    }

    // Read second row
    record, err := r.Read()
    checkError("Some other error occurred", err)
    // Check record fields types
    for i, v := range record {
        var value interface{}
        if value, err = strconv.Atoi(v); err != nil {
            if value, err = strconv.ParseFloat(v, 64); err != nil {
                if value, err = strconv.ParseBool(v); err != nil {
                    if value, err = strconv.ParseBool(v); err != nil { // <== How to do this with unknown layout
                        // Value is a string
                        headerTypes[i] = "string"
                        value = v
                        fmt.Println(reflect.TypeOf(value), reflect.ValueOf(value))
                    } else {
                        // Value is a timestamp
                        headerTypes[i] = "time"
                        fmt.Println(reflect.TypeOf(value), reflect.ValueOf(value))
                    }
                } else {
                    // Value is a bool
                    headerTypes[i] = "bool"
                    fmt.Println(reflect.TypeOf(value), reflect.ValueOf(value))
                }
            } else {
                // Value is a float
                headerTypes[i] = "float"
                fmt.Println(reflect.TypeOf(value), reflect.ValueOf(value))
            }
        } else {
            // Value is an int
            headerTypes[i] = "int"
            fmt.Println(reflect.TypeOf(value), reflect.ValueOf(value))
        }
    }

    for i, _ := range header {
        fmt.Printf("Header: %v \tis\t %v\n", headerNames[i], headerTypes[i])
    }
}

func checkError(message string, err error) {
    // Error Logging
    if err != nil {
        log.Fatal(message, err)
    }
}

And with csv file as:

name,age,developer
"Hasan","46.4","true"

I got an output as:

Header: name       is  string
Header: age        is  float
Header: developer  is  bool

The output is correct.

The thing that I could not do is the one is checking if the field is string as I do not know what layout the field could be.

I aware I can pasre string to time as per the format stated at https://go.dev/src/time/format.go, and can build a custom parser, something like:

    test, err := fmtdate.Parse("MM/DD/YYYY", "10/15/1983")
    if err != nil {
        panic(err)
    }

But this will work only (as per my knowledge) if I know the layout?

So, again my question is, how can I parse time, or what shall I do to be able to parse it, if I do not know the layout?

Thanks to the comment by Burak, I found the solution by using this package: github.com/araddon/dateparse

// Normal parse.  Equivalent Timezone rules as time.Parse()
t, err := dateparse.ParseAny("3/1/2014")

// Parse Strict, error on ambigous mm/dd vs dd/mm dates
t, err := dateparse.ParseStrict("3/1/2014")
> returns error 

// Return a string that represents the layout to parse the given date-time.
layout, err := dateparse.ParseFormat("May 8, 2009 5:57:51 PM")
> "Jan 2, 2006 3:04:05 PM"