writeErrorResponseJSON(ctx, w, errorCodes.ToAPIErrWithErr(ErrAdminConfigBadJSON, err), r.URL)
		return
	}

	var cfg madmin.TierConfig
	json := jsoniter.ConfigCompatibleWithStandardLibrary
	if err := json.Unmarshal(reqBytes, &cfg); err != nil {
		writeErrorResponseJSON(ctx, w, toAdminAPIErr(ctx, err), r.URL)
		return
	}

	var ignoreInUse bool
	if forceStr := r.Form.Get("force"); forceStr != "" {

		o = msgp.AppendInt(o, za0002.NumVersions)
		// string "no"
		o = append(o, 0xa2, 0x6e, 0x6f)
		o = msgp.AppendInt(o, za0002.NumObjects)
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *allTierStats) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {

		return
	}

	var out bytes.Buffer
	json.Indent(&out, body, "", "  ")
	fmt.Printf("Received JSON payload:\n%s\n", out.String())

	reqMap := make(map[string]interface{})
	err = json.Unmarshal(body, &reqMap)
	if err != nil {
		writeErrorResponse(w, err)
		return
	}

	m := reqMap["input"].(map[string]interface{})
	accountValue := m["account"].(string)
	actionValue := m["action"].(string)

	o = msgp.AppendString(o, z.Key)
	// string "Context"
	o = append(o, 0xa7, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74)
	o = msgp.AppendString(o, z.Context)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *BatchJobKeyRotateEncryption) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {

	bootstrapDumpAny, err := w.getSection(bootstrap)
	if err != nil {
		return nil, err
	}
	bootstrapDump := &admin.BootstrapConfigDump{}
	err = bootstrapDumpAny.UnmarshalTo(bootstrapDump)
	if err != nil {
		return nil, err
	}
	return bootstrapDump, nil

	endpointsDumpAny, err := w.getSection(endpoints)
	if err != nil {
		return nil, nil
	}
	endpointsDump := &admin.EndpointsConfigDump{}
	err = endpointsDumpAny.UnmarshalTo(endpointsDump)
	if err != nil {
		return nil, err
	}
	return endpointsDump, nil

	ecdsDumpAny, err := w.getSections(ecds)
	if err != nil {
		return nil, err
	}

	ecdsDump := &admin.EcdsConfigDump{}
	for _, dump := range ecdsDumpAny {
		ecds := &admin.EcdsConfigDump{}
		err = dump.UnmarshalTo(ecds)
		if err != nil {
			return nil, err
		}

		ecdsDump.EcdsFilters = append(ecdsDump.EcdsFilters, ecds.EcdsFilters...)
	}

	if err != nil {
		return nil, err
	}
	return ecdsDump, nil

		t.Fatalf("Number of logs want %v, got %v logs: %v", want, got, gotLogs)
	}
	i := 0
	for _, l := range gotLogs {
		var parsedLog map[string]any
		assert.NoError(t, json.Unmarshal([]byte(l), &parsedLog))
		if parsedLog["scope"] != "cni-plugin" {
			// Each log is 2x: one direct, and one over UDS. Just test the UDS one
			continue
		}
		// remove scope since it is constant and not needed to test

		if r.RouteConfig != nil {
			routeTyped := &route.RouteConfiguration{}
			// Support v2 or v3 in config dump. See ads.go:RequestedTypes for more info.
			r.RouteConfig.TypeUrl = v3.RouteType
			err = r.RouteConfig.UnmarshalTo(routeTyped)
			if err != nil {
				return nil, err
			}
			routes = append(routes, routeTyped)
		}
	}
	for _, r := range routeDump.StaticRouteConfigs {
		if r.RouteConfig != nil {

func ReadCNIConfigMap(path string) (map[string]any, error) {
	cniConfig, err := os.ReadFile(path)
	if err != nil {
		return nil, err
	}

	var cniConfigMap map[string]any
	if err = json.Unmarshal(cniConfig, &cniConfigMap); err != nil {
		return nil, fmt.Errorf("%s: %w", path, err)
	}

	return cniConfigMap, nil
}