How to map a TypeScript array of multiple values to Go struct

You could define your own struct with a custom unmarshal func like this:

package main

import (
    "encoding/json"
    "errors"
    "fmt"
)

var json_data = []byte(`{
  "data": [
    [
      35241,
      7753,
      7750,
      "0xbb2b8038a1640196fbe3e38816f3e67cba72d940",
      "spot",
      true
    ],
    [60259, 7746, null, "#7746/USD", "internal", true, ["requote", 145]]
  ]
}`)

func main() {
    var doc Document
    if err := json.Unmarshal(json_data, &doc); err != nil {
        panic(err)
    }
    for _, r := range doc.Data {
        fmt.Printf("%+v\n", r)
        if r.Optional != nil {
            fmt.Printf("  with optional: %+v\n", *r.Optional)
        }
    }
}

type Document struct {
    Data []Row `json:"data"`
}

type Row struct {
    SomeInt    int
    SomeString string
    // Simplified
    Optional *MoreData
}

type MoreData struct {
    SomeString string
    SomeInt    int
}

func (row *Row) UnmarshalJSON(data []byte) error {
    var elements []json.RawMessage
    if err := json.Unmarshal(data, &elements); err != nil {
        return err
    }
    if len(elements) < 6 {
        return errors.New("too few elements")
    }

    if err := json.Unmarshal(elements[0], &row.SomeInt); err != nil {
        return err
    }
    if err := json.Unmarshal(elements[3], &row.SomeString); err != nil {
        return err
    }

    if len(elements) == 7 {
        var more MoreData
        if err := json.Unmarshal(elements[6], &more); err != nil {
            return err
        }
        row.Optional = &more
    }

    return nil
}

func (more *MoreData) UnmarshalJSON(data []byte) error {
    var elements []json.RawMessage
    if err := json.Unmarshal(data, &elements); err != nil {
        return err
    }
    if len(elements) < 2 {
        return errors.New("too few elements")
    }

    if err := json.Unmarshal(elements[0], &more.SomeString); err != nil {
        return err
    }
    if err := json.Unmarshal(elements[1], &more.SomeInt); err != nil {
        return err
    }

    return nil
}

https://go.dev/play/p/zLgENBZ0fkC

Based in your example data I'm assuming the numbers are integers. If the JSON can contain floating point numbers (which would be valid number), you would have to adjust the type of course...

I think you could use reflect to define a struct with each field related to an index of data's type and define the UnmarshalJSON function similarly to what @some-user did.

package main

import (
    "encoding/json"
    "fmt"
    "reflect"
    "strconv"
    "strings"
)

var json_data = []byte(`{
    "data": [
      [
        35241,
        7753,
        7750,
        "0xbb2b8038a1640196fbe3e38816f3e67cba72d940",
        "spot",
        true
      ],
      [60259, 7746, null, "#7746/USD", "internal", true, ["requote", 145]]
    ]
  }`)

func main() {
    var doc Document
    if err := json.Unmarshal(json_data, &doc); err != nil {
        panic(err)
    }
    for _, r := range doc.Data {
        fmt.Printf("%+v\n", r)
        if r.G != nil {
            fmt.Printf("  with optional: %+v\n", r.G)
        }
    }
}

type Document struct {
    Data []*Row `json:"data"`
}

type Row struct {
    A int           `idx:"0"`
    B int           `idx:"1"`
    C int           `idx:"2"`
    D string        `idx:"3"`
    E string        `idx:"4"`
    F string        `idx:"5"`
    G *OptionalItem `idx:"6,optional"`
}

func (r *Row) UnmarshalJSON(data []byte) error {
    typ := reflect.TypeOf(r)
    val := reflect.ValueOf(r)

    return unmarshalArray(typ, val, data)
}

type OptionalItem struct {
    A string `idx:"0"`
    B string `idx:"1"`
}

func (oi *OptionalItem) UnmarshalJSON(data []byte) error {
    typ := reflect.TypeOf(oi)
    val := reflect.ValueOf(oi)

    return unmarshalArray(typ, val, data)
}

func unmarshalArray(typ reflect.Type, val reflect.Value, data []byte) error {
    var items []json.RawMessage
    if err := json.Unmarshal(data, &items); err != nil {
        return err
    }

    for i := 0; i < typ.Elem().NumField(); i++ {
        field := typ.Elem().Field(i)

        if value, ok := field.Tag.Lookup("idx"); ok {
            idx, optional, err := splitTag(value)
            if err != nil {
                return err
            }

            if !optional || (optional && len(items) > idx) {
                if string(items[idx]) == "null" {
                    continue
                }

                valueField := val.Elem().FieldByName(field.Name)
                if _, ok := valueField.Interface().(json.Unmarshaler); ok {
                    if err := json.Unmarshal(items[idx], valueField.Addr().Interface()); err != nil {
                        return err
                    }
                } else {
                    if valueField.Kind() == reflect.String {
                        valueField.SetString(string(items[idx]))
                    } else if valueField.Kind() == reflect.Int {
                        number, err := strconv.Atoi(string(items[idx]))
                        if err != nil {
                            return err
                        }
                        valueField.SetInt(int64(number))
                    } else {
                        valueField.Set(reflect.ValueOf(items[idx]))
                    }
                }
            }
        }
    }

    return nil
}

func splitTag(tag string) (idx int, optional bool, err error) {
    ops := strings.Split(tag, ",")
    if len(ops) < 1 {
        err = fmt.Errorf("empty 'idx' tag")
        return
    } else if len(ops) > 1 {
        optional = ops[1] == "optional"
    }

    idx, err = strconv.Atoi(ops[0])
    if err != nil {
        return
    }

    return
}

https://go.dev/play/p/x8hC_8JfjGG

There are still some checks missing but it does illustrates the idea.