oas_json_gen.go

// Code generated by ogen, DO NOT EDIT.

package pyroscopeapi

import (
	"math/bits"
	"strconv"

	"github.com/go-faster/errors"
	"github.com/go-faster/jx"

	"github.com/ogen-go/ogen/validate"
)

// Encode implements json.Marshaler.
func (s *ApplicationMetadata) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *ApplicationMetadata) encodeFields(e *jx.Encoder) {
	{
		if s.Name.Set {
			e.FieldStart("name")
			s.Name.Encode(e)
		}
	}
	{
		if s.SpyName.Set {
			e.FieldStart("spyName")
			s.SpyName.Encode(e)
		}
	}
	{
		if s.SampleRate.Set {
			e.FieldStart("sampleRate")
			s.SampleRate.Encode(e)
		}
	}
	{
		if s.Units.Set {
			e.FieldStart("units")
			s.Units.Encode(e)
		}
	}
}

var jsonFieldsNameOfApplicationMetadata = [4]string{
	0: "name",
	1: "spyName",
	2: "sampleRate",
	3: "units",
}

// Decode decodes ApplicationMetadata from json.
func (s *ApplicationMetadata) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ApplicationMetadata to nil")
	}

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "name":
			if err := func() error {
				s.Name.Reset()
				if err := s.Name.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"name\"")
			}
		case "spyName":
			if err := func() error {
				s.SpyName.Reset()
				if err := s.SpyName.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"spyName\"")
			}
		case "sampleRate":
			if err := func() error {
				s.SampleRate.Reset()
				if err := s.SampleRate.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"sampleRate\"")
			}
		case "units":
			if err := func() error {
				s.Units.Reset()
				if err := s.Units.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"units\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode ApplicationMetadata")
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *ApplicationMetadata) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ApplicationMetadata) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes ApplicationMetadataUnits as json.
func (s ApplicationMetadataUnits) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes ApplicationMetadataUnits from json.
func (s *ApplicationMetadataUnits) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ApplicationMetadataUnits to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch ApplicationMetadataUnits(v) {
	case ApplicationMetadataUnitsSamples:
		*s = ApplicationMetadataUnitsSamples
	case ApplicationMetadataUnitsObjects:
		*s = ApplicationMetadataUnitsObjects
	case ApplicationMetadataUnitsGoroutines:
		*s = ApplicationMetadataUnitsGoroutines
	case ApplicationMetadataUnitsBytes:
		*s = ApplicationMetadataUnitsBytes
	case ApplicationMetadataUnitsLockNanoseconds:
		*s = ApplicationMetadataUnitsLockNanoseconds
	case ApplicationMetadataUnitsLockSamples:
		*s = ApplicationMetadataUnitsLockSamples
	default:
		*s = ApplicationMetadataUnits(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s ApplicationMetadataUnits) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ApplicationMetadataUnits) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes Error as json.
func (s Error) Encode(e *jx.Encoder) {
	unwrapped := string(s)

	e.Str(unwrapped)
}

// Decode decodes Error from json.
func (s *Error) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode Error to nil")
	}
	var unwrapped string
	if err := func() error {
		v, err := d.Str()
		unwrapped = string(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = Error(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s Error) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Error) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *FlamebearerMetadataV1) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *FlamebearerMetadataV1) encodeFields(e *jx.Encoder) {
	{
		if s.Name.Set {
			e.FieldStart("name")
			s.Name.Encode(e)
		}
	}
	{
		if s.SpyName.Set {
			e.FieldStart("spyName")
			s.SpyName.Encode(e)
		}
	}
	{
		if s.SampleRate.Set {
			e.FieldStart("sampleRate")
			s.SampleRate.Encode(e)
		}
	}
	{
		if s.Units.Set {
			e.FieldStart("units")
			s.Units.Encode(e)
		}
	}
	{
		e.FieldStart("format")
		e.Str(s.Format)
	}
}

var jsonFieldsNameOfFlamebearerMetadataV1 = [5]string{
	0: "name",
	1: "spyName",
	2: "sampleRate",
	3: "units",
	4: "format",
}

// Decode decodes FlamebearerMetadataV1 from json.
func (s *FlamebearerMetadataV1) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode FlamebearerMetadataV1 to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "name":
			if err := func() error {
				s.Name.Reset()
				if err := s.Name.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"name\"")
			}
		case "spyName":
			if err := func() error {
				s.SpyName.Reset()
				if err := s.SpyName.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"spyName\"")
			}
		case "sampleRate":
			if err := func() error {
				s.SampleRate.Reset()
				if err := s.SampleRate.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"sampleRate\"")
			}
		case "units":
			if err := func() error {
				s.Units.Reset()
				if err := s.Units.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"units\"")
			}
		case "format":
			requiredBitSet[0] |= 1 << 4
			if err := func() error {
				v, err := d.Str()
				s.Format = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"format\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode FlamebearerMetadataV1")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00010000,
	} {
		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
			// Mask only required fields and check equality to mask using XOR.
			//
			// If XOR result is not zero, result is not equal to expected, so some fields are missed.
			// Bits of fields which would be set are actually bits of missed fields.
			missed := bits.OnesCount8(result)
			for bitN := 0; bitN < missed; bitN++ {
				bitIdx := bits.TrailingZeros8(result)
				fieldIdx := i*8 + bitIdx
				var name string
				if fieldIdx < len(jsonFieldsNameOfFlamebearerMetadataV1) {
					name = jsonFieldsNameOfFlamebearerMetadataV1[fieldIdx]
				} else {
					name = strconv.Itoa(fieldIdx)
				}
				failures = append(failures, validate.FieldError{
					Name:  name,
					Error: validate.ErrFieldRequired,
				})
				// Reset bit.
				result &^= 1 << bitIdx
			}
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *FlamebearerMetadataV1) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *FlamebearerMetadataV1) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes FlamebearerMetadataV1Units as json.
func (s FlamebearerMetadataV1Units) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes FlamebearerMetadataV1Units from json.
func (s *FlamebearerMetadataV1Units) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode FlamebearerMetadataV1Units to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch FlamebearerMetadataV1Units(v) {
	case FlamebearerMetadataV1UnitsSamples:
		*s = FlamebearerMetadataV1UnitsSamples
	case FlamebearerMetadataV1UnitsObjects:
		*s = FlamebearerMetadataV1UnitsObjects
	case FlamebearerMetadataV1UnitsGoroutines:
		*s = FlamebearerMetadataV1UnitsGoroutines
	case FlamebearerMetadataV1UnitsBytes:
		*s = FlamebearerMetadataV1UnitsBytes
	case FlamebearerMetadataV1UnitsLockNanoseconds:
		*s = FlamebearerMetadataV1UnitsLockNanoseconds
	case FlamebearerMetadataV1UnitsLockSamples:
		*s = FlamebearerMetadataV1UnitsLockSamples
	default:
		*s = FlamebearerMetadataV1Units(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s FlamebearerMetadataV1Units) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *FlamebearerMetadataV1Units) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *FlamebearerProfileV1) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *FlamebearerProfileV1) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("flamebearer")
		s.Flamebearer.Encode(e)
	}
	{
		e.FieldStart("metadata")
		s.Metadata.Encode(e)
	}
	{
		if s.Timeline.Set {
			e.FieldStart("timeline")
			s.Timeline.Encode(e)
		}
	}
	{
		if s.Groups.Set {
			e.FieldStart("groups")
			s.Groups.Encode(e)
		}
	}
	{
		if s.Heatmap.Set {
			e.FieldStart("heatmap")
			s.Heatmap.Encode(e)
		}
	}
	{
		if s.LeftTicks.Set {
			e.FieldStart("leftTicks")
			s.LeftTicks.Encode(e)
		}
	}
	{
		if s.RightTicks.Set {
			e.FieldStart("rightTicks")
			s.RightTicks.Encode(e)
		}
	}
}

var jsonFieldsNameOfFlamebearerProfileV1 = [7]string{
	0: "flamebearer",
	1: "metadata",
	2: "timeline",
	3: "groups",
	4: "heatmap",
	5: "leftTicks",
	6: "rightTicks",
}

// Decode decodes FlamebearerProfileV1 from json.
func (s *FlamebearerProfileV1) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode FlamebearerProfileV1 to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "flamebearer":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Flamebearer.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"flamebearer\"")
			}
		case "metadata":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Metadata.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"metadata\"")
			}
		case "timeline":
			if err := func() error {
				s.Timeline.Reset()
				if err := s.Timeline.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"timeline\"")
			}
		case "groups":
			if err := func() error {
				s.Groups.Reset()
				if err := s.Groups.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"groups\"")
			}
		case "heatmap":
			if err := func() error {
				s.Heatmap.Reset()
				if err := s.Heatmap.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"heatmap\"")
			}
		case "leftTicks":
			if err := func() error {
				s.LeftTicks.Reset()
				if err := s.LeftTicks.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"leftTicks\"")
			}
		case "rightTicks":
			if err := func() error {
				s.RightTicks.Reset()
				if err := s.RightTicks.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"rightTicks\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode FlamebearerProfileV1")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000011,
	} {
		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
			// Mask only required fields and check equality to mask using XOR.
			//
			// If XOR result is not zero, result is not equal to expected, so some fields are missed.
			// Bits of fields which would be set are actually bits of missed fields.
			missed := bits.OnesCount8(result)
			for bitN := 0; bitN < missed; bitN++ {
				bitIdx := bits.TrailingZeros8(result)
				fieldIdx := i*8 + bitIdx
				var name string
				if fieldIdx < len(jsonFieldsNameOfFlamebearerProfileV1) {
					name = jsonFieldsNameOfFlamebearerProfileV1[fieldIdx]
				} else {
					name = strconv.Itoa(fieldIdx)
				}
				failures = append(failures, validate.FieldError{
					Name:  name,
					Error: validate.ErrFieldRequired,
				})
				// Reset bit.
				result &^= 1 << bitIdx
			}
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *FlamebearerProfileV1) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *FlamebearerProfileV1) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s FlamebearerProfileV1Groups) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields implements json.Marshaler.
func (s FlamebearerProfileV1Groups) encodeFields(e *jx.Encoder) {
	for k, elem := range s {
		e.FieldStart(k)

		elem.Encode(e)
	}
}

// Decode decodes FlamebearerProfileV1Groups from json.
func (s *FlamebearerProfileV1Groups) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode FlamebearerProfileV1Groups to nil")
	}
	m := s.init()
	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		var elem FlamebearerTimelineV1
		if err := func() error {
			if err := elem.Decode(d); err != nil {
				return err
			}
			return nil
		}(); err != nil {
			return errors.Wrapf(err, "decode field %q", k)
		}
		m[string(k)] = elem
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode FlamebearerProfileV1Groups")
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s FlamebearerProfileV1Groups) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *FlamebearerProfileV1Groups) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *FlamebearerTimelineV1) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *FlamebearerTimelineV1) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("startTime")
		e.Int64(s.StartTime)
	}
	{
		e.FieldStart("samples")
		e.ArrStart()
		for _, elem := range s.Samples {
			e.UInt64(elem)
		}
		e.ArrEnd()
	}
	{
		e.FieldStart("durationDelta")
		e.Int64(s.DurationDelta)
	}
	{
		if s.Watermarks.Set {
			e.FieldStart("watermarks")
			s.Watermarks.Encode(e)
		}
	}
}

var jsonFieldsNameOfFlamebearerTimelineV1 = [4]string{
	0: "startTime",
	1: "samples",
	2: "durationDelta",
	3: "watermarks",
}

// Decode decodes FlamebearerTimelineV1 from json.
func (s *FlamebearerTimelineV1) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode FlamebearerTimelineV1 to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "startTime":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Int64()
				s.StartTime = int64(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"startTime\"")
			}
		case "samples":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				s.Samples = make([]uint64, 0)
				if err := d.Arr(func(d *jx.Decoder) error {
					var elem uint64
					v, err := d.UInt64()
					elem = uint64(v)
					if err != nil {
						return err
					}
					s.Samples = append(s.Samples, elem)
					return nil
				}); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"samples\"")
			}
		case "durationDelta":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				v, err := d.Int64()
				s.DurationDelta = int64(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"durationDelta\"")
			}
		case "watermarks":
			if err := func() error {
				s.Watermarks.Reset()
				if err := s.Watermarks.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"watermarks\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode FlamebearerTimelineV1")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000111,
	} {
		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
			// Mask only required fields and check equality to mask using XOR.
			//
			// If XOR result is not zero, result is not equal to expected, so some fields are missed.
			// Bits of fields which would be set are actually bits of missed fields.
			missed := bits.OnesCount8(result)
			for bitN := 0; bitN < missed; bitN++ {
				bitIdx := bits.TrailingZeros8(result)
				fieldIdx := i*8 + bitIdx
				var name string
				if fieldIdx < len(jsonFieldsNameOfFlamebearerTimelineV1) {
					name = jsonFieldsNameOfFlamebearerTimelineV1[fieldIdx]
				} else {
					name = strconv.Itoa(fieldIdx)
				}
				failures = append(failures, validate.FieldError{
					Name:  name,
					Error: validate.ErrFieldRequired,
				})
				// Reset bit.
				result &^= 1 << bitIdx
			}
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *FlamebearerTimelineV1) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *FlamebearerTimelineV1) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s FlamebearerTimelineV1Watermarks) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields implements json.Marshaler.
func (s FlamebearerTimelineV1Watermarks) encodeFields(e *jx.Encoder) {
	for k, elem := range s {
		e.FieldStart(k)

		e.Int64(elem)
	}
}

// Decode decodes FlamebearerTimelineV1Watermarks from json.
func (s *FlamebearerTimelineV1Watermarks) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode FlamebearerTimelineV1Watermarks to nil")
	}
	m := s.init()
	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		var elem int64
		if err := func() error {
			v, err := d.Int64()
			elem = int64(v)
			if err != nil {
				return err
			}
			return nil
		}(); err != nil {
			return errors.Wrapf(err, "decode field %q", k)
		}
		m[string(k)] = elem
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode FlamebearerTimelineV1Watermarks")
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s FlamebearerTimelineV1Watermarks) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *FlamebearerTimelineV1Watermarks) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *FlamebearerV1) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *FlamebearerV1) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("names")
		e.ArrStart()
		for _, elem := range s.Names {
			e.Str(elem)
		}
		e.ArrEnd()
	}
	{
		e.FieldStart("levels")
		e.ArrStart()
		for _, elem := range s.Levels {
			e.ArrStart()
			for _, elem := range elem {
				e.Int(elem)
			}
			e.ArrEnd()
		}
		e.ArrEnd()
	}
	{
		e.FieldStart("numTicks")
		e.Int(s.NumTicks)
	}
	{
		e.FieldStart("maxSelf")
		e.Int(s.MaxSelf)
	}
}

var jsonFieldsNameOfFlamebearerV1 = [4]string{
	0: "names",
	1: "levels",
	2: "numTicks",
	3: "maxSelf",
}

// Decode decodes FlamebearerV1 from json.
func (s *FlamebearerV1) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode FlamebearerV1 to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "names":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				s.Names = make([]string, 0)
				if err := d.Arr(func(d *jx.Decoder) error {
					var elem string
					v, err := d.Str()
					elem = string(v)
					if err != nil {
						return err
					}
					s.Names = append(s.Names, elem)
					return nil
				}); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"names\"")
			}
		case "levels":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				s.Levels = make([][]int, 0)
				if err := d.Arr(func(d *jx.Decoder) error {
					var elem []int
					elem = make([]int, 0)
					if err := d.Arr(func(d *jx.Decoder) error {
						var elemElem int
						v, err := d.Int()
						elemElem = int(v)
						if err != nil {
							return err
						}
						elem = append(elem, elemElem)
						return nil
					}); err != nil {
						return err
					}
					s.Levels = append(s.Levels, elem)
					return nil
				}); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"levels\"")
			}
		case "numTicks":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				v, err := d.Int()
				s.NumTicks = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"numTicks\"")
			}
		case "maxSelf":
			requiredBitSet[0] |= 1 << 3
			if err := func() error {
				v, err := d.Int()
				s.MaxSelf = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"maxSelf\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode FlamebearerV1")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00001111,
	} {
		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
			// Mask only required fields and check equality to mask using XOR.
			//
			// If XOR result is not zero, result is not equal to expected, so some fields are missed.
			// Bits of fields which would be set are actually bits of missed fields.
			missed := bits.OnesCount8(result)
			for bitN := 0; bitN < missed; bitN++ {
				bitIdx := bits.TrailingZeros8(result)
				fieldIdx := i*8 + bitIdx
				var name string
				if fieldIdx < len(jsonFieldsNameOfFlamebearerV1) {
					name = jsonFieldsNameOfFlamebearerV1[fieldIdx]
				} else {
					name = strconv.Itoa(fieldIdx)
				}
				failures = append(failures, validate.FieldError{
					Name:  name,
					Error: validate.ErrFieldRequired,
				})
				// Reset bit.
				result &^= 1 << bitIdx
			}
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *FlamebearerV1) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *FlamebearerV1) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *Heatmap) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *Heatmap) encodeFields(e *jx.Encoder) {
	{
		if s.Values != nil {
			e.FieldStart("values")
			e.ArrStart()
			for _, elem := range s.Values {
				e.ArrStart()
				for _, elem := range elem {
					e.UInt64(elem)
				}
				e.ArrEnd()
			}
			e.ArrEnd()
		}
	}
	{
		if s.TimeBuckets.Set {
			e.FieldStart("timeBuckets")
			s.TimeBuckets.Encode(e)
		}
	}
	{
		if s.ValueBuckets.Set {
			e.FieldStart("valueBuckets")
			s.ValueBuckets.Encode(e)
		}
	}
	{
		if s.StartTime.Set {
			e.FieldStart("startTime")
			s.StartTime.Encode(e)
		}
	}
	{
		if s.EndTime.Set {
			e.FieldStart("endTime")
			s.EndTime.Encode(e)
		}
	}
	{
		if s.MinValue.Set {
			e.FieldStart("minValue")
			s.MinValue.Encode(e)
		}
	}
	{
		if s.MaxValue.Set {
			e.FieldStart("maxValue")
			s.MaxValue.Encode(e)
		}
	}
	{
		if s.MinDepth.Set {
			e.FieldStart("minDepth")
			s.MinDepth.Encode(e)
		}
	}
	{
		if s.MaxDepth.Set {
			e.FieldStart("maxDepth")
			s.MaxDepth.Encode(e)
		}
	}
}

var jsonFieldsNameOfHeatmap = [9]string{
	0: "values",
	1: "timeBuckets",
	2: "valueBuckets",
	3: "startTime",
	4: "endTime",
	5: "minValue",
	6: "maxValue",
	7: "minDepth",
	8: "maxDepth",
}

// Decode decodes Heatmap from json.
func (s *Heatmap) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode Heatmap to nil")
	}

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "values":
			if err := func() error {
				s.Values = make([][]uint64, 0)
				if err := d.Arr(func(d *jx.Decoder) error {
					var elem []uint64
					elem = make([]uint64, 0)
					if err := d.Arr(func(d *jx.Decoder) error {
						var elemElem uint64
						v, err := d.UInt64()
						elemElem = uint64(v)
						if err != nil {
							return err
						}
						elem = append(elem, elemElem)
						return nil
					}); err != nil {
						return err
					}
					s.Values = append(s.Values, elem)
					return nil
				}); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"values\"")
			}
		case "timeBuckets":
			if err := func() error {
				s.TimeBuckets.Reset()
				if err := s.TimeBuckets.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"timeBuckets\"")
			}
		case "valueBuckets":
			if err := func() error {
				s.ValueBuckets.Reset()
				if err := s.ValueBuckets.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"valueBuckets\"")
			}
		case "startTime":
			if err := func() error {
				s.StartTime.Reset()
				if err := s.StartTime.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"startTime\"")
			}
		case "endTime":
			if err := func() error {
				s.EndTime.Reset()
				if err := s.EndTime.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"endTime\"")
			}
		case "minValue":
			if err := func() error {
				s.MinValue.Reset()
				if err := s.MinValue.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"minValue\"")
			}
		case "maxValue":
			if err := func() error {
				s.MaxValue.Reset()
				if err := s.MaxValue.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"maxValue\"")
			}
		case "minDepth":
			if err := func() error {
				s.MinDepth.Reset()
				if err := s.MinDepth.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"minDepth\"")
			}
		case "maxDepth":
			if err := func() error {
				s.MaxDepth.Reset()
				if err := s.MaxDepth.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"maxDepth\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode Heatmap")
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *Heatmap) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Heatmap) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes LabelValues as json.
func (s LabelValues) Encode(e *jx.Encoder) {
	unwrapped := []string(s)

	e.ArrStart()
	for _, elem := range unwrapped {
		e.Str(elem)
	}
	e.ArrEnd()
}

// Decode decodes LabelValues from json.
func (s *LabelValues) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode LabelValues to nil")
	}
	var unwrapped []string
	if err := func() error {
		unwrapped = make([]string, 0)
		if err := d.Arr(func(d *jx.Decoder) error {
			var elem string
			v, err := d.Str()
			elem = string(v)
			if err != nil {
				return err
			}
			unwrapped = append(unwrapped, elem)
			return nil
		}); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = LabelValues(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s LabelValues) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *LabelValues) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes Labels as json.
func (s Labels) Encode(e *jx.Encoder) {
	unwrapped := []string(s)

	e.ArrStart()
	for _, elem := range unwrapped {
		e.Str(elem)
	}
	e.ArrEnd()
}

// Decode decodes Labels from json.
func (s *Labels) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode Labels to nil")
	}
	var unwrapped []string
	if err := func() error {
		unwrapped = make([]string, 0)
		if err := d.Arr(func(d *jx.Decoder) error {
			var elem string
			v, err := d.Str()
			elem = string(v)
			if err != nil {
				return err
			}
			unwrapped = append(unwrapped, elem)
			return nil
		}); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = Labels(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s Labels) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Labels) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes ApplicationMetadataUnits as json.
func (o OptApplicationMetadataUnits) Encode(e *jx.Encoder) {
	if !o.Set {
		return
	}
	e.Str(string(o.Value))
}

// Decode decodes ApplicationMetadataUnits from json.
func (o *OptApplicationMetadataUnits) Decode(d *jx.Decoder) error {
	if o == nil {
		return errors.New("invalid: unable to decode OptApplicationMetadataUnits to nil")
	}
	o.Set = true
	if err := o.Value.Decode(d); err != nil {
		return err
	}
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptApplicationMetadataUnits) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptApplicationMetadataUnits) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes FlamebearerMetadataV1Units as json.
func (o OptFlamebearerMetadataV1Units) Encode(e *jx.Encoder) {
	if !o.Set {
		return
	}
	e.Str(string(o.Value))
}

// Decode decodes FlamebearerMetadataV1Units from json.
func (o *OptFlamebearerMetadataV1Units) Decode(d *jx.Decoder) error {
	if o == nil {
		return errors.New("invalid: unable to decode OptFlamebearerMetadataV1Units to nil")
	}
	o.Set = true
	if err := o.Value.Decode(d); err != nil {
		return err
	}
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptFlamebearerMetadataV1Units) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptFlamebearerMetadataV1Units) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes FlamebearerProfileV1Groups as json.
func (o OptFlamebearerProfileV1Groups) Encode(e *jx.Encoder) {
	if !o.Set {
		return
	}
	o.Value.Encode(e)
}

// Decode decodes FlamebearerProfileV1Groups from json.
func (o *OptFlamebearerProfileV1Groups) Decode(d *jx.Decoder) error {
	if o == nil {
		return errors.New("invalid: unable to decode OptFlamebearerProfileV1Groups to nil")
	}
	o.Set = true
	o.Value = make(FlamebearerProfileV1Groups)
	if err := o.Value.Decode(d); err != nil {
		return err
	}
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptFlamebearerProfileV1Groups) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptFlamebearerProfileV1Groups) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes FlamebearerTimelineV1 as json.
func (o OptFlamebearerTimelineV1) Encode(e *jx.Encoder) {
	if !o.Set {
		return
	}
	o.Value.Encode(e)
}

// Decode decodes FlamebearerTimelineV1 from json.
func (o *OptFlamebearerTimelineV1) Decode(d *jx.Decoder) error {
	if o == nil {
		return errors.New("invalid: unable to decode OptFlamebearerTimelineV1 to nil")
	}
	o.Set = true
	if err := o.Value.Decode(d); err != nil {
		return err
	}
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptFlamebearerTimelineV1) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptFlamebearerTimelineV1) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes FlamebearerTimelineV1Watermarks as json.
func (o OptFlamebearerTimelineV1Watermarks) Encode(e *jx.Encoder) {
	if !o.Set {
		return
	}
	o.Value.Encode(e)
}

// Decode decodes FlamebearerTimelineV1Watermarks from json.
func (o *OptFlamebearerTimelineV1Watermarks) Decode(d *jx.Decoder) error {
	if o == nil {
		return errors.New("invalid: unable to decode OptFlamebearerTimelineV1Watermarks to nil")
	}
	o.Set = true
	o.Value = make(FlamebearerTimelineV1Watermarks)
	if err := o.Value.Decode(d); err != nil {
		return err
	}
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptFlamebearerTimelineV1Watermarks) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptFlamebearerTimelineV1Watermarks) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes int64 as json.
func (o OptInt64) Encode(e *jx.Encoder) {
	if !o.Set {
		return
	}
	e.Int64(int64(o.Value))
}

// Decode decodes int64 from json.
func (o *OptInt64) Decode(d *jx.Decoder) error {
	if o == nil {
		return errors.New("invalid: unable to decode OptInt64 to nil")
	}
	o.Set = true
	v, err := d.Int64()
	if err != nil {
		return err
	}
	o.Value = int64(v)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptInt64) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptInt64) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes Heatmap as json.
func (o OptNilHeatmap) Encode(e *jx.Encoder) {
	if !o.Set {
		return
	}
	if o.Null {
		e.Null()
		return
	}
	o.Value.Encode(e)
}

// Decode decodes Heatmap from json.
func (o *OptNilHeatmap) Decode(d *jx.Decoder) error {
	if o == nil {
		return errors.New("invalid: unable to decode OptNilHeatmap to nil")
	}
	if d.Next() == jx.Null {
		if err := d.Null(); err != nil {
			return err
		}

		var v Heatmap
		o.Value = v
		o.Set = true
		o.Null = true
		return nil
	}
	o.Set = true
	o.Null = false
	if err := o.Value.Decode(d); err != nil {
		return err
	}
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptNilHeatmap) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptNilHeatmap) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes string as json.
func (o OptString) Encode(e *jx.Encoder) {
	if !o.Set {
		return
	}
	e.Str(string(o.Value))
}

// Decode decodes string from json.
func (o *OptString) Decode(d *jx.Decoder) error {
	if o == nil {
		return errors.New("invalid: unable to decode OptString to nil")
	}
	o.Set = true
	v, err := d.Str()
	if err != nil {
		return err
	}
	o.Value = string(v)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptString) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptString) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes uint32 as json.
func (o OptUint32) Encode(e *jx.Encoder) {
	if !o.Set {
		return
	}
	e.UInt32(uint32(o.Value))
}

// Decode decodes uint32 from json.
func (o *OptUint32) Decode(d *jx.Decoder) error {
	if o == nil {
		return errors.New("invalid: unable to decode OptUint32 to nil")
	}
	o.Set = true
	v, err := d.UInt32()
	if err != nil {
		return err
	}
	o.Value = uint32(v)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptUint32) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptUint32) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes uint64 as json.
func (o OptUint64) Encode(e *jx.Encoder) {
	if !o.Set {
		return
	}
	e.UInt64(uint64(o.Value))
}

// Decode decodes uint64 from json.
func (o *OptUint64) Decode(d *jx.Decoder) error {
	if o == nil {
		return errors.New("invalid: unable to decode OptUint64 to nil")
	}
	o.Set = true
	v, err := d.UInt64()
	if err != nil {
		return err
	}
	o.Value = uint64(v)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptUint64) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptUint64) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}