How can I access a field in JSON data from an empty interface{} type?

I am new to Go and I know this is probably a simple answer but I am getting tripped up accessing a JSON value in an empty interface. The data is coming from a Twilio Go Helper library (https://pkg.go.dev/github.com/twilio/twilio-go@v1.0.0/rest/lookups/v2#LookupsV2PhoneNumber.LineTypeIntelligence) and I am trying to access a value in the object
LineTypeIntelligence *interface{} `json:"line_type_intelligence,omitempty"`

If I print the object it shows as a map
fmt.Println(*resp.LineTypeIntelligence)
which
outputs
map[carrier_name:Verizon Wireless error_code:<nil> mobile_country_code:311 mobile_network_code:489 type:mobile]

I tried to directly access a value in the map using
carrier_name := resp.LineTypeIntelligence["carrier_name"].(string)

This unfortunately generates a compiler error:
invalid operation: cannot index resp.LineTypeIntelligence (variable of type *interface{})

As far as this goes:

carrier_name  := resp.LineTypeIntelligence["carrier_name"].(string)

That won't work, as resp.LineTypeIntelligence is of type *interface{} (or *any for short). You cannot access it as though it were a map. The type interface{} simply denotes that whatever value is assigned to this field, it implements an empty interface (which is to say: everything implements an interface of 0 methods, so the value could be anything).

To access the data itself, you'll need some type assertions/casts, and copy the values into a map that is easier to use:

LTIMap, ok := *resp.LineTypeIntelligence.(map[string]any)
if !ok {
    // return errors.Errorf("expected LineTypeIntelligence to be a map, instead saw %T (%#v)", *resp.LineTypeIntelligence, *resp.LineTypeIntelligence)
    panic("handle error because we expected the value to be a map, but it's something else")
}
// now LTIMap is map[string]any
carrierName, ok := LTIMap["carrier_name"].(string)
if !ok {
    return errors.Ner("carrier name not a string")
}
// and so on

This is, of course rather tedious. Considering you already know the map will contain a carrier_name key, why not unmarshal the data into a different type?

Looking at the data, this ought to work:

type LTI struct {
    CarrierName string  `json:"carrier_name"`
    ErrCode     *int    `json:"error_code,omitempty"` // or string, or whatever
    MobCC       int     `json:"mobile_country_code"` // twilio might use string for these
    MobNC       int     `json:"mobile_network_code"`
    Type        string  `json:"type"`
}

It's not the most efficient way to go about things, but the quickest way to get this data into your own object would be to marshal it again, and unmarshal it in your own type:

b, _ := json.Marshal(resp.LineTypeIntelligence)
lti := LTI{}
if err := json.Unmarshal(b, &lti); err != nil {
    // handle error
}
fmt.Printf("carrier name: %s\n", lti.CarrierName)

Pedantry, perhaps, but golang has been often criticised for being "too opinionated" WRT how you should format/write your code. That criticism has died down because the strict formatting has proven to be a good thing. Because the code is formatted the same, people can just look at code written by anyone and focus on what it does rather than how it was written.

Because of the benefits of conformity across projects/code-bases, in addition to gofmt, the golang repo has a wiki entry covering a ton of additional conventions: Code Review Comments

Your question contains variables like carrier_name. In golang, it's recommended to snakeCase variable names.

You also do something like resp.LineTypeIntelligence["carrier_name"].(string). Fetching values from a map should not be combined with a cast, however. Safe map access looks like this:

v, ok := m["carrier_name"]
if !ok {
    // v will be the nil value of the value type of your map
    // ie map[string]int => v == 0
    // map[string]string => v == ""
    // map[string]*int   => v == nil
    // you can initialise v to a safe value if needed, or return an error
}
// ok was true, the map does indeed contain a value for the key "carrier_name"
name, ok := v.(string)
if !ok {
    // though the map contained the required key, it turned out not to be a string...
}
// type assertion was successful: map contained the key, and the value was indeed a string