how to create user defined struct for array of different user defined object in golang

I am trying to parse json object in golang.

Below is the json structure :

{
	"properties": {
		"alertType": "VM_EICAR",
		"resourceIdentifiers": [{
				"azureResourceId": "/Microsoft.Compute/virtualMachines/vm1",
				"type": "AzureResource"
			},
			{
				"workspaceId": "f419f624-acad-4d89-b86d-f62fa387f019",
				"workspaceSubscriptionId": "20ff7fc3-e762-44dd-bd96-b71116dcdc23",
				"workspaceResourceGroup": "myRg1",
				"agentId": "75724a01-f021-4aa8-9ec2-329792373e6e",
				"type": "LogAnalytics"
			}
		],

		"vendorName": "Microsoft",
		"status": "New"

	}
}

I have below user defined types.

type AzureResourceIdentifier struct {
	AzureResourceId					string						`json:"azureResourceId"`
	Type							string						`json:"type"`			
}

type LogAnalyticsIdentifier struct{
	AgentId						string			`json:"agentId"`
	Type						string			`json:"type"`
	WorkspaceId					string			`json:"workspaceId"`
	WorkspaceResourceGroup		string			`json:"workspaceResourceGroup"`
	WorkspaceSubscriptionId		string			`json:"workspaceSubscriptionId"`
}

I have a top level user defined type as properties as below.
it has resourceIdentifiers as array of two other user defined types(defined above),

• AzureResourceIdentifier
• LogAnalyticsIdentifier

how can I define type of resourceIdentifiers in properties ?

type Properties struct{
	      alertType				  string						
	      resourceIdentifiers               ???                   	    `
          vendorName			      string						`
	      status 		      string						   
}

Note: I have a existing connector and we are provisioned to input the struct of the parsing json, we cannot override or add any function.

There are a couple of options here.

1. []map[string]interface{}

Using a map will allow any JSON object in the array to be parsed, but burdens you with having to safely extract information after the fact.

2. []interface{}

Each is going to be a map under the hood, unless non-JSON object elements can also be in the JSON array. No reason to use it over map[string]interface{} in your case.

3. A slice of a new struct type which covers all possible fields: []ResourceIdentifier

type ResourceIdentifier struct {
    AzureResourceId             string `json:"azureResourceId"`
    AgentId                     string `json:"agentId"`
    WorkspaceId                 string `json:"workspaceId"`
    WorkspaceResourceGroup      string `json:"workspaceResourceGroup"`
    WorkspaceSubscriptionId     string `json:"workspaceSubscriptionId"`
    
    Type                        string `json:"type"`
}

This is probably the laziest solution. It allows you to get where you want to quickly, at the cost of wasting some memory and creating a non self-explanatory data design which might cause confusion if later trying to serialize with it again.

4. A new struct type + custom unmarshalling implementation.

type ResourceIdentifiers struct {
    AzureResourceIdentifiers []AzureResourceIdentifier
    LogAnalyticsIdentifiers []LogAnalyticsIdentifier
}

Implement json.Unmarshaler to decide which type of struct to construct and in which slice to put it.