// Code generated by ogen, DO NOT EDIT.
package api
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 *AlertRule) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *AlertRule) encodeFields(e *jx.Encoder) {
{
if s.ID.Set {
e.FieldStart("id")
s.ID.Encode(e)
}
}
{
if s.UID.Set {
e.FieldStart("uid")
s.UID.Encode(e)
}
}
{
if s.OrgID.Set {
e.FieldStart("orgID")
s.OrgID.Encode(e)
}
}
{
if s.FolderUID.Set {
e.FieldStart("folderUID")
s.FolderUID.Encode(e)
}
}
{
if s.RuleGroup.Set {
e.FieldStart("ruleGroup")
s.RuleGroup.Encode(e)
}
}
{
if s.Title.Set {
e.FieldStart("title")
s.Title.Encode(e)
}
}
{
if s.Condition.Set {
e.FieldStart("condition")
s.Condition.Encode(e)
}
}
{
if s.Data != nil {
e.FieldStart("data")
e.ArrStart()
for _, elem := range s.Data {
if len(elem) != 0 {
e.Raw(elem)
}
}
e.ArrEnd()
}
}
{
if s.NoDataState.Set {
e.FieldStart("noDataState")
s.NoDataState.Encode(e)
}
}
{
if s.ExecErrState.Set {
e.FieldStart("execErrState")
s.ExecErrState.Encode(e)
}
}
{
if s.For.Set {
e.FieldStart("for")
s.For.Encode(e)
}
}
{
if len(s.Annotations) != 0 {
e.FieldStart("annotations")
e.Raw(s.Annotations)
}
}
{
if len(s.Labels) != 0 {
e.FieldStart("labels")
e.Raw(s.Labels)
}
}
{
if s.Updated.Set {
e.FieldStart("updated")
s.Updated.Encode(e)
}
}
{
if s.Provenance.Set {
e.FieldStart("provenance")
s.Provenance.Encode(e)
}
}
}
var jsonFieldsNameOfAlertRule = [15]string{
0: "id",
1: "uid",
2: "orgID",
3: "folderUID",
4: "ruleGroup",
5: "title",
6: "condition",
7: "data",
8: "noDataState",
9: "execErrState",
10: "for",
11: "annotations",
12: "labels",
13: "updated",
14: "provenance",
}
// Decode decodes AlertRule from json.
func (s *AlertRule) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode AlertRule to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "id":
if err := func() error {
s.ID.Reset()
if err := s.ID.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"id\"")
}
case "uid":
if err := func() error {
s.UID.Reset()
if err := s.UID.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"uid\"")
}
case "orgID":
if err := func() error {
s.OrgID.Reset()
if err := s.OrgID.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"orgID\"")
}
case "folderUID":
if err := func() error {
s.FolderUID.Reset()
if err := s.FolderUID.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"folderUID\"")
}
case "ruleGroup":
if err := func() error {
s.RuleGroup.Reset()
if err := s.RuleGroup.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ruleGroup\"")
}
case "title":
if err := func() error {
s.Title.Reset()
if err := s.Title.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"title\"")
}
case "condition":
if err := func() error {
s.Condition.Reset()
if err := s.Condition.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"condition\"")
}
case "data":
if err := func() error {
s.Data = make([]jx.Raw, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem jx.Raw
v, err := d.RawAppend(nil)
elem = jx.Raw(v)
if err != nil {
return err
}
s.Data = append(s.Data, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"data\"")
}
case "noDataState":
if err := func() error {
s.NoDataState.Reset()
if err := s.NoDataState.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"noDataState\"")
}
case "execErrState":
if err := func() error {
s.ExecErrState.Reset()
if err := s.ExecErrState.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"execErrState\"")
}
case "for":
if err := func() error {
s.For.Reset()
if err := s.For.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"for\"")
}
case "annotations":
if err := func() error {
v, err := d.RawAppend(nil)
s.Annotations = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"annotations\"")
}
case "labels":
if err := func() error {
v, err := d.RawAppend(nil)
s.Labels = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"labels\"")
}
case "updated":
if err := func() error {
s.Updated.Reset()
if err := s.Updated.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"updated\"")
}
case "provenance":
if err := func() error {
s.Provenance.Reset()
if err := s.Provenance.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"provenance\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode AlertRule")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *AlertRule) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AlertRule) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *Annotation) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *Annotation) encodeFields(e *jx.Encoder) {
{
if s.ID.Set {
e.FieldStart("id")
s.ID.Encode(e)
}
}
{
if s.AlertId.Set {
e.FieldStart("alertId")
s.AlertId.Encode(e)
}
}
{
if s.AlertName.Set {
e.FieldStart("alertName")
s.AlertName.Encode(e)
}
}
{
if s.DashboardId.Set {
e.FieldStart("dashboardId")
s.DashboardId.Encode(e)
}
}
{
if s.DashboardUID.Set {
e.FieldStart("dashboardUID")
s.DashboardUID.Encode(e)
}
}
{
if s.PanelId.Set {
e.FieldStart("panelId")
s.PanelId.Encode(e)
}
}
{
if s.UserId.Set {
e.FieldStart("userId")
s.UserId.Encode(e)
}
}
{
if s.NewState.Set {
e.FieldStart("newState")
s.NewState.Encode(e)
}
}
{
if s.PrevState.Set {
e.FieldStart("prevState")
s.PrevState.Encode(e)
}
}
{
if s.Created.Set {
e.FieldStart("created")
s.Created.Encode(e)
}
}
{
if s.Updated.Set {
e.FieldStart("updated")
s.Updated.Encode(e)
}
}
{
if s.Time.Set {
e.FieldStart("time")
s.Time.Encode(e)
}
}
{
if s.TimeEnd.Set {
e.FieldStart("timeEnd")
s.TimeEnd.Encode(e)
}
}
{
if s.Text.Set {
e.FieldStart("text")
s.Text.Encode(e)
}
}
{
if s.Tags != nil {
e.FieldStart("tags")
e.ArrStart()
for _, elem := range s.Tags {
e.Str(elem)
}
e.ArrEnd()
}
}
}
var jsonFieldsNameOfAnnotation = [15]string{
0: "id",
1: "alertId",
2: "alertName",
3: "dashboardId",
4: "dashboardUID",
5: "panelId",
6: "userId",
7: "newState",
8: "prevState",
9: "created",
10: "updated",
11: "time",
12: "timeEnd",
13: "text",
14: "tags",
}
// Decode decodes Annotation from json.
func (s *Annotation) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode Annotation to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "id":
if err := func() error {
s.ID.Reset()
if err := s.ID.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"id\"")
}
case "alertId":
if err := func() error {
s.AlertId.Reset()
if err := s.AlertId.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"alertId\"")
}
case "alertName":
if err := func() error {
s.AlertName.Reset()
if err := s.AlertName.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"alertName\"")
}
case "dashboardId":
if err := func() error {
s.DashboardId.Reset()
if err := s.DashboardId.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"dashboardId\"")
}
case "dashboardUID":
if err := func() error {
s.DashboardUID.Reset()
if err := s.DashboardUID.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"dashboardUID\"")
}
case "panelId":
if err := func() error {
s.PanelId.Reset()
if err := s.PanelId.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"panelId\"")
}
case "userId":
if err := func() error {
s.UserId.Reset()
if err := s.UserId.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"userId\"")
}
case "newState":
if err := func() error {
s.NewState.Reset()
if err := s.NewState.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"newState\"")
}
case "prevState":
if err := func() error {
s.PrevState.Reset()
if err := s.PrevState.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"prevState\"")
}
case "created":
if err := func() error {
s.Created.Reset()
if err := s.Created.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"created\"")
}
case "updated":
if err := func() error {
s.Updated.Reset()
if err := s.Updated.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"updated\"")
}
case "time":
if err := func() error {
s.Time.Reset()
if err := s.Time.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"time\"")
}
case "timeEnd":
if err := func() error {
s.TimeEnd.Reset()
if err := s.TimeEnd.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"timeEnd\"")
}
case "text":
if err := func() error {
s.Text.Reset()
if err := s.Text.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"text\"")
}
case "tags":
if err := func() error {
s.Tags = 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.Tags = append(s.Tags, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"tags\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode Annotation")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *Annotation) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Annotation) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *ContactPoint) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *ContactPoint) encodeFields(e *jx.Encoder) {
{
if s.UID.Set {
e.FieldStart("uid")
s.UID.Encode(e)
}
}
{
if s.Name.Set {
e.FieldStart("name")
s.Name.Encode(e)
}
}
{
if s.Type.Set {
e.FieldStart("type")
s.Type.Encode(e)
}
}
{
if len(s.Settings) != 0 {
e.FieldStart("settings")
e.Raw(s.Settings)
}
}
{
if s.DisableResolveMessage.Set {
e.FieldStart("disableResolveMessage")
s.DisableResolveMessage.Encode(e)
}
}
{
if s.Provenance.Set {
e.FieldStart("provenance")
s.Provenance.Encode(e)
}
}
}
var jsonFieldsNameOfContactPoint = [6]string{
0: "uid",
1: "name",
2: "type",
3: "settings",
4: "disableResolveMessage",
5: "provenance",
}
// Decode decodes ContactPoint from json.
func (s *ContactPoint) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode ContactPoint to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "uid":
if err := func() error {
s.UID.Reset()
if err := s.UID.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"uid\"")
}
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 "type":
if err := func() error {
s.Type.Reset()
if err := s.Type.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"type\"")
}
case "settings":
if err := func() error {
v, err := d.RawAppend(nil)
s.Settings = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"settings\"")
}
case "disableResolveMessage":
if err := func() error {
s.DisableResolveMessage.Reset()
if err := s.DisableResolveMessage.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"disableResolveMessage\"")
}
case "provenance":
if err := func() error {
s.Provenance.Reset()
if err := s.Provenance.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"provenance\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode ContactPoint")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *ContactPoint) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ContactPoint) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *CreateAlertRuleRequest) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *CreateAlertRuleRequest) encodeFields(e *jx.Encoder) {
{
e.FieldStart("title")
e.Str(s.Title)
}
{
e.FieldStart("ruleGroup")
e.Str(s.RuleGroup)
}
{
e.FieldStart("folderUID")
e.Str(s.FolderUID)
}
{
e.FieldStart("condition")
e.Str(s.Condition)
}
{
e.FieldStart("data")
e.ArrStart()
for _, elem := range s.Data {
if len(elem) != 0 {
e.Raw(elem)
}
}
e.ArrEnd()
}
{
if s.NoDataState.Set {
e.FieldStart("noDataState")
s.NoDataState.Encode(e)
}
}
{
if s.ExecErrState.Set {
e.FieldStart("execErrState")
s.ExecErrState.Encode(e)
}
}
{
if s.For.Set {
e.FieldStart("for")
s.For.Encode(e)
}
}
{
if len(s.Annotations) != 0 {
e.FieldStart("annotations")
e.Raw(s.Annotations)
}
}
{
if len(s.Labels) != 0 {
e.FieldStart("labels")
e.Raw(s.Labels)
}
}
}
var jsonFieldsNameOfCreateAlertRuleRequest = [10]string{
0: "title",
1: "ruleGroup",
2: "folderUID",
3: "condition",
4: "data",
5: "noDataState",
6: "execErrState",
7: "for",
8: "annotations",
9: "labels",
}
// Decode decodes CreateAlertRuleRequest from json.
func (s *CreateAlertRuleRequest) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode CreateAlertRuleRequest to nil")
}
var requiredBitSet [2]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "title":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Str()
s.Title = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"title\"")
}
case "ruleGroup":
requiredBitSet[0] |= 1 << 1
if err := func() error {
v, err := d.Str()
s.RuleGroup = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ruleGroup\"")
}
case "folderUID":
requiredBitSet[0] |= 1 << 2
if err := func() error {
v, err := d.Str()
s.FolderUID = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"folderUID\"")
}
case "condition":
requiredBitSet[0] |= 1 << 3
if err := func() error {
v, err := d.Str()
s.Condition = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"condition\"")
}
case "data":
requiredBitSet[0] |= 1 << 4
if err := func() error {
s.Data = make([]jx.Raw, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem jx.Raw
v, err := d.RawAppend(nil)
elem = jx.Raw(v)
if err != nil {
return err
}
s.Data = append(s.Data, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"data\"")
}
case "noDataState":
if err := func() error {
s.NoDataState.Reset()
if err := s.NoDataState.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"noDataState\"")
}
case "execErrState":
if err := func() error {
s.ExecErrState.Reset()
if err := s.ExecErrState.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"execErrState\"")
}
case "for":
if err := func() error {
s.For.Reset()
if err := s.For.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"for\"")
}
case "annotations":
if err := func() error {
v, err := d.RawAppend(nil)
s.Annotations = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"annotations\"")
}
case "labels":
if err := func() error {
v, err := d.RawAppend(nil)
s.Labels = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"labels\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode CreateAlertRuleRequest")
}
// Validate required fields.
var failures []validate.FieldError
for i, mask := range [2]uint8{
0b00011111,
0b00000000,
} {
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(jsonFieldsNameOfCreateAlertRuleRequest) {
name = jsonFieldsNameOfCreateAlertRuleRequest[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 *CreateAlertRuleRequest) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CreateAlertRuleRequest) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *CreateAnnotationRequest) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *CreateAnnotationRequest) encodeFields(e *jx.Encoder) {
{
if s.DashboardUID.Set {
e.FieldStart("dashboardUID")
s.DashboardUID.Encode(e)
}
}
{
if s.PanelId.Set {
e.FieldStart("panelId")
s.PanelId.Encode(e)
}
}
{
if s.Time.Set {
e.FieldStart("time")
s.Time.Encode(e)
}
}
{
if s.TimeEnd.Set {
e.FieldStart("timeEnd")
s.TimeEnd.Encode(e)
}
}
{
e.FieldStart("text")
e.Str(s.Text)
}
{
if s.Tags != nil {
e.FieldStart("tags")
e.ArrStart()
for _, elem := range s.Tags {
e.Str(elem)
}
e.ArrEnd()
}
}
}
var jsonFieldsNameOfCreateAnnotationRequest = [6]string{
0: "dashboardUID",
1: "panelId",
2: "time",
3: "timeEnd",
4: "text",
5: "tags",
}
// Decode decodes CreateAnnotationRequest from json.
func (s *CreateAnnotationRequest) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode CreateAnnotationRequest to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "dashboardUID":
if err := func() error {
s.DashboardUID.Reset()
if err := s.DashboardUID.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"dashboardUID\"")
}
case "panelId":
if err := func() error {
s.PanelId.Reset()
if err := s.PanelId.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"panelId\"")
}
case "time":
if err := func() error {
s.Time.Reset()
if err := s.Time.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"time\"")
}
case "timeEnd":
if err := func() error {
s.TimeEnd.Reset()
if err := s.TimeEnd.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"timeEnd\"")
}
case "text":
requiredBitSet[0] |= 1 << 4
if err := func() error {
v, err := d.Str()
s.Text = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"text\"")
}
case "tags":
if err := func() error {
s.Tags = 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.Tags = append(s.Tags, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"tags\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode CreateAnnotationRequest")
}
// 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(jsonFieldsNameOfCreateAnnotationRequest) {
name = jsonFieldsNameOfCreateAnnotationRequest[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 *CreateAnnotationRequest) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CreateAnnotationRequest) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *CreateAnnotationResponse) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *CreateAnnotationResponse) encodeFields(e *jx.Encoder) {
{
if s.ID.Set {
e.FieldStart("id")
s.ID.Encode(e)
}
}
{
if s.Message.Set {
e.FieldStart("message")
s.Message.Encode(e)
}
}
}
var jsonFieldsNameOfCreateAnnotationResponse = [2]string{
0: "id",
1: "message",
}
// Decode decodes CreateAnnotationResponse from json.
func (s *CreateAnnotationResponse) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode CreateAnnotationResponse to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "id":
if err := func() error {
s.ID.Reset()
if err := s.ID.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"id\"")
}
case "message":
if err := func() error {
s.Message.Reset()
if err := s.Message.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"message\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode CreateAnnotationResponse")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *CreateAnnotationResponse) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CreateAnnotationResponse) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *CreateContactPointRequest) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *CreateContactPointRequest) encodeFields(e *jx.Encoder) {
{
e.FieldStart("name")
e.Str(s.Name)
}
{
e.FieldStart("type")
e.Str(s.Type)
}
{
if len(s.Settings) != 0 {
e.FieldStart("settings")
e.Raw(s.Settings)
}
}
{
if s.DisableResolveMessage.Set {
e.FieldStart("disableResolveMessage")
s.DisableResolveMessage.Encode(e)
}
}
}
var jsonFieldsNameOfCreateContactPointRequest = [4]string{
0: "name",
1: "type",
2: "settings",
3: "disableResolveMessage",
}
// Decode decodes CreateContactPointRequest from json.
func (s *CreateContactPointRequest) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode CreateContactPointRequest to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "name":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Str()
s.Name = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"name\"")
}
case "type":
requiredBitSet[0] |= 1 << 1
if err := func() error {
v, err := d.Str()
s.Type = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"type\"")
}
case "settings":
requiredBitSet[0] |= 1 << 2
if err := func() error {
v, err := d.RawAppend(nil)
s.Settings = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"settings\"")
}
case "disableResolveMessage":
if err := func() error {
s.DisableResolveMessage.Reset()
if err := s.DisableResolveMessage.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"disableResolveMessage\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode CreateContactPointRequest")
}
// 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(jsonFieldsNameOfCreateContactPointRequest) {
name = jsonFieldsNameOfCreateContactPointRequest[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 *CreateContactPointRequest) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CreateContactPointRequest) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *CreateFolderRequest) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *CreateFolderRequest) encodeFields(e *jx.Encoder) {
{
if s.UID.Set {
e.FieldStart("uid")
s.UID.Encode(e)
}
}
{
e.FieldStart("title")
e.Str(s.Title)
}
{
if s.ParentUid.Set {
e.FieldStart("parentUid")
s.ParentUid.Encode(e)
}
}
}
var jsonFieldsNameOfCreateFolderRequest = [3]string{
0: "uid",
1: "title",
2: "parentUid",
}
// Decode decodes CreateFolderRequest from json.
func (s *CreateFolderRequest) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode CreateFolderRequest to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "uid":
if err := func() error {
s.UID.Reset()
if err := s.UID.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"uid\"")
}
case "title":
requiredBitSet[0] |= 1 << 1
if err := func() error {
v, err := d.Str()
s.Title = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"title\"")
}
case "parentUid":
if err := func() error {
s.ParentUid.Reset()
if err := s.ParentUid.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"parentUid\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode CreateFolderRequest")
}
// Validate required fields.
var failures []validate.FieldError
for i, mask := range [1]uint8{
0b00000010,
} {
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(jsonFieldsNameOfCreateFolderRequest) {
name = jsonFieldsNameOfCreateFolderRequest[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 *CreateFolderRequest) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CreateFolderRequest) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *DashboardFullWithMeta) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *DashboardFullWithMeta) encodeFields(e *jx.Encoder) {
{
if s.Meta.Set {
e.FieldStart("meta")
s.Meta.Encode(e)
}
}
{
if len(s.Dashboard) != 0 {
e.FieldStart("dashboard")
e.Raw(s.Dashboard)
}
}
}
var jsonFieldsNameOfDashboardFullWithMeta = [2]string{
0: "meta",
1: "dashboard",
}
// Decode decodes DashboardFullWithMeta from json.
func (s *DashboardFullWithMeta) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode DashboardFullWithMeta to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "meta":
if err := func() error {
s.Meta.Reset()
if err := s.Meta.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"meta\"")
}
case "dashboard":
if err := func() error {
v, err := d.RawAppend(nil)
s.Dashboard = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"dashboard\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode DashboardFullWithMeta")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *DashboardFullWithMeta) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *DashboardFullWithMeta) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *DashboardMeta) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *DashboardMeta) encodeFields(e *jx.Encoder) {
{
if s.Type.Set {
e.FieldStart("type")
s.Type.Encode(e)
}
}
{
if s.CanSave.Set {
e.FieldStart("canSave")
s.CanSave.Encode(e)
}
}
{
if s.CanEdit.Set {
e.FieldStart("canEdit")
s.CanEdit.Encode(e)
}
}
{
if s.CanAdmin.Set {
e.FieldStart("canAdmin")
s.CanAdmin.Encode(e)
}
}
{
if s.CanStar.Set {
e.FieldStart("canStar")
s.CanStar.Encode(e)
}
}
{
if s.CanDelete.Set {
e.FieldStart("canDelete")
s.CanDelete.Encode(e)
}
}
{
if s.Slug.Set {
e.FieldStart("slug")
s.Slug.Encode(e)
}
}
{
if s.URL.Set {
e.FieldStart("url")
s.URL.Encode(e)
}
}
{
if s.Expires.Set {
e.FieldStart("expires")
s.Expires.Encode(e)
}
}
{
if s.Created.Set {
e.FieldStart("created")
s.Created.Encode(e)
}
}
{
if s.Updated.Set {
e.FieldStart("updated")
s.Updated.Encode(e)
}
}
{
if s.UpdatedBy.Set {
e.FieldStart("updatedBy")
s.UpdatedBy.Encode(e)
}
}
{
if s.CreatedBy.Set {
e.FieldStart("createdBy")
s.CreatedBy.Encode(e)
}
}
{
if s.Version.Set {
e.FieldStart("version")
s.Version.Encode(e)
}
}
{
if s.HasAcl.Set {
e.FieldStart("hasAcl")
s.HasAcl.Encode(e)
}
}
{
if s.IsFolder.Set {
e.FieldStart("isFolder")
s.IsFolder.Encode(e)
}
}
{
if s.FolderId.Set {
e.FieldStart("folderId")
s.FolderId.Encode(e)
}
}
{
if s.FolderUid.Set {
e.FieldStart("folderUid")
s.FolderUid.Encode(e)
}
}
{
if s.FolderTitle.Set {
e.FieldStart("folderTitle")
s.FolderTitle.Encode(e)
}
}
{
if s.FolderUrl.Set {
e.FieldStart("folderUrl")
s.FolderUrl.Encode(e)
}
}
{
if s.Provisioned.Set {
e.FieldStart("provisioned")
s.Provisioned.Encode(e)
}
}
{
if s.ProvisionedExternalId.Set {
e.FieldStart("provisionedExternalId")
s.ProvisionedExternalId.Encode(e)
}
}
}
var jsonFieldsNameOfDashboardMeta = [22]string{
0: "type",
1: "canSave",
2: "canEdit",
3: "canAdmin",
4: "canStar",
5: "canDelete",
6: "slug",
7: "url",
8: "expires",
9: "created",
10: "updated",
11: "updatedBy",
12: "createdBy",
13: "version",
14: "hasAcl",
15: "isFolder",
16: "folderId",
17: "folderUid",
18: "folderTitle",
19: "folderUrl",
20: "provisioned",
21: "provisionedExternalId",
}
// Decode decodes DashboardMeta from json.
func (s *DashboardMeta) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode DashboardMeta to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "type":
if err := func() error {
s.Type.Reset()
if err := s.Type.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"type\"")
}
case "canSave":
if err := func() error {
s.CanSave.Reset()
if err := s.CanSave.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"canSave\"")
}
case "canEdit":
if err := func() error {
s.CanEdit.Reset()
if err := s.CanEdit.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"canEdit\"")
}
case "canAdmin":
if err := func() error {
s.CanAdmin.Reset()
if err := s.CanAdmin.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"canAdmin\"")
}
case "canStar":
if err := func() error {
s.CanStar.Reset()
if err := s.CanStar.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"canStar\"")
}
case "canDelete":
if err := func() error {
s.CanDelete.Reset()
if err := s.CanDelete.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"canDelete\"")
}
case "slug":
if err := func() error {
s.Slug.Reset()
if err := s.Slug.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"slug\"")
}
case "url":
if err := func() error {
s.URL.Reset()
if err := s.URL.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"url\"")
}
case "expires":
if err := func() error {
s.Expires.Reset()
if err := s.Expires.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"expires\"")
}
case "created":
if err := func() error {
s.Created.Reset()
if err := s.Created.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"created\"")
}
case "updated":
if err := func() error {
s.Updated.Reset()
if err := s.Updated.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"updated\"")
}
case "updatedBy":
if err := func() error {
s.UpdatedBy.Reset()
if err := s.UpdatedBy.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"updatedBy\"")
}
case "createdBy":
if err := func() error {
s.CreatedBy.Reset()
if err := s.CreatedBy.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"createdBy\"")
}
case "version":
if err := func() error {
s.Version.Reset()
if err := s.Version.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"version\"")
}
case "hasAcl":
if err := func() error {
s.HasAcl.Reset()
if err := s.HasAcl.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"hasAcl\"")
}
case "isFolder":
if err := func() error {
s.IsFolder.Reset()
if err := s.IsFolder.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"isFolder\"")
}
case "folderId":
if err := func() error {
s.FolderId.Reset()
if err := s.FolderId.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"folderId\"")
}
case "folderUid":
if err := func() error {
s.FolderUid.Reset()
if err := s.FolderUid.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"folderUid\"")
}
case "folderTitle":
if err := func() error {
s.FolderTitle.Reset()
if err := s.FolderTitle.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"folderTitle\"")
}
case "folderUrl":
if err := func() error {
s.FolderUrl.Reset()
if err := s.FolderUrl.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"folderUrl\"")
}
case "provisioned":
if err := func() error {
s.Provisioned.Reset()
if err := s.Provisioned.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"provisioned\"")
}
case "provisionedExternalId":
if err := func() error {
s.ProvisionedExternalId.Reset()
if err := s.ProvisionedExternalId.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"provisionedExternalId\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode DashboardMeta")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *DashboardMeta) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *DashboardMeta) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *Datasource) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *Datasource) encodeFields(e *jx.Encoder) {
{
if s.ID.Set {
e.FieldStart("id")
s.ID.Encode(e)
}
}
{
if s.UID.Set {
e.FieldStart("uid")
s.UID.Encode(e)
}
}
{
if s.OrgId.Set {
e.FieldStart("orgId")
s.OrgId.Encode(e)
}
}
{
if s.Name.Set {
e.FieldStart("name")
s.Name.Encode(e)
}
}
{
if s.Type.Set {
e.FieldStart("type")
s.Type.Encode(e)
}
}
{
if s.TypeName.Set {
e.FieldStart("typeName")
s.TypeName.Encode(e)
}
}
{
if s.TypeLogoUrl.Set {
e.FieldStart("typeLogoUrl")
s.TypeLogoUrl.Encode(e)
}
}
{
if s.Access.Set {
e.FieldStart("access")
s.Access.Encode(e)
}
}
{
if s.URL.Set {
e.FieldStart("url")
s.URL.Encode(e)
}
}
{
if s.User.Set {
e.FieldStart("user")
s.User.Encode(e)
}
}
{
if s.Database.Set {
e.FieldStart("database")
s.Database.Encode(e)
}
}
{
if s.BasicAuth.Set {
e.FieldStart("basicAuth")
s.BasicAuth.Encode(e)
}
}
{
if s.IsDefault.Set {
e.FieldStart("isDefault")
s.IsDefault.Encode(e)
}
}
{
if s.ReadOnly.Set {
e.FieldStart("readOnly")
s.ReadOnly.Encode(e)
}
}
}
var jsonFieldsNameOfDatasource = [14]string{
0: "id",
1: "uid",
2: "orgId",
3: "name",
4: "type",
5: "typeName",
6: "typeLogoUrl",
7: "access",
8: "url",
9: "user",
10: "database",
11: "basicAuth",
12: "isDefault",
13: "readOnly",
}
// Decode decodes Datasource from json.
func (s *Datasource) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode Datasource to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "id":
if err := func() error {
s.ID.Reset()
if err := s.ID.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"id\"")
}
case "uid":
if err := func() error {
s.UID.Reset()
if err := s.UID.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"uid\"")
}
case "orgId":
if err := func() error {
s.OrgId.Reset()
if err := s.OrgId.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"orgId\"")
}
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 "type":
if err := func() error {
s.Type.Reset()
if err := s.Type.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"type\"")
}
case "typeName":
if err := func() error {
s.TypeName.Reset()
if err := s.TypeName.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"typeName\"")
}
case "typeLogoUrl":
if err := func() error {
s.TypeLogoUrl.Reset()
if err := s.TypeLogoUrl.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"typeLogoUrl\"")
}
case "access":
if err := func() error {
s.Access.Reset()
if err := s.Access.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"access\"")
}
case "url":
if err := func() error {
s.URL.Reset()
if err := s.URL.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"url\"")
}
case "user":
if err := func() error {
s.User.Reset()
if err := s.User.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"user\"")
}
case "database":
if err := func() error {
s.Database.Reset()
if err := s.Database.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"database\"")
}
case "basicAuth":
if err := func() error {
s.BasicAuth.Reset()
if err := s.BasicAuth.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"basicAuth\"")
}
case "isDefault":
if err := func() error {
s.IsDefault.Reset()
if err := s.IsDefault.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"isDefault\"")
}
case "readOnly":
if err := func() error {
s.ReadOnly.Reset()
if err := s.ReadOnly.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"readOnly\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode Datasource")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *Datasource) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Datasource) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *DeleteAnnotationResponse) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *DeleteAnnotationResponse) encodeFields(e *jx.Encoder) {
{
if s.Message.Set {
e.FieldStart("message")
s.Message.Encode(e)
}
}
}
var jsonFieldsNameOfDeleteAnnotationResponse = [1]string{
0: "message",
}
// Decode decodes DeleteAnnotationResponse from json.
func (s *DeleteAnnotationResponse) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode DeleteAnnotationResponse to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "message":
if err := func() error {
s.Message.Reset()
if err := s.Message.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"message\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode DeleteAnnotationResponse")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *DeleteAnnotationResponse) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *DeleteAnnotationResponse) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *DeleteDashboardResponse) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *DeleteDashboardResponse) encodeFields(e *jx.Encoder) {
{
if s.Title.Set {
e.FieldStart("title")
s.Title.Encode(e)
}
}
{
if s.Message.Set {
e.FieldStart("message")
s.Message.Encode(e)
}
}
{
if s.ID.Set {
e.FieldStart("id")
s.ID.Encode(e)
}
}
}
var jsonFieldsNameOfDeleteDashboardResponse = [3]string{
0: "title",
1: "message",
2: "id",
}
// Decode decodes DeleteDashboardResponse from json.
func (s *DeleteDashboardResponse) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode DeleteDashboardResponse to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "title":
if err := func() error {
s.Title.Reset()
if err := s.Title.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"title\"")
}
case "message":
if err := func() error {
s.Message.Reset()
if err := s.Message.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"message\"")
}
case "id":
if err := func() error {
s.ID.Reset()
if err := s.ID.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"id\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode DeleteDashboardResponse")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *DeleteDashboardResponse) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *DeleteDashboardResponse) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *DeleteFolderResponse) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *DeleteFolderResponse) encodeFields(e *jx.Encoder) {
{
if s.Title.Set {
e.FieldStart("title")
s.Title.Encode(e)
}
}
{
if s.Message.Set {
e.FieldStart("message")
s.Message.Encode(e)
}
}
{
if s.ID.Set {
e.FieldStart("id")
s.ID.Encode(e)
}
}
}
var jsonFieldsNameOfDeleteFolderResponse = [3]string{
0: "title",
1: "message",
2: "id",
}
// Decode decodes DeleteFolderResponse from json.
func (s *DeleteFolderResponse) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode DeleteFolderResponse to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "title":
if err := func() error {
s.Title.Reset()
if err := s.Title.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"title\"")
}
case "message":
if err := func() error {
s.Message.Reset()
if err := s.Message.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"message\"")
}
case "id":
if err := func() error {
s.ID.Reset()
if err := s.ID.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"id\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode DeleteFolderResponse")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *DeleteFolderResponse) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *DeleteFolderResponse) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *DsQueryRequest) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *DsQueryRequest) encodeFields(e *jx.Encoder) {
{
if s.From.Set {
e.FieldStart("from")
s.From.Encode(e)
}
}
{
if s.To.Set {
e.FieldStart("to")
s.To.Encode(e)
}
}
{
e.FieldStart("queries")
e.ArrStart()
for _, elem := range s.Queries {
if len(elem) != 0 {
e.Raw(elem)
}
}
e.ArrEnd()
}
}
var jsonFieldsNameOfDsQueryRequest = [3]string{
0: "from",
1: "to",
2: "queries",
}
// Decode decodes DsQueryRequest from json.
func (s *DsQueryRequest) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode DsQueryRequest to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "from":
if err := func() error {
s.From.Reset()
if err := s.From.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"from\"")
}
case "to":
if err := func() error {
s.To.Reset()
if err := s.To.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"to\"")
}
case "queries":
requiredBitSet[0] |= 1 << 2
if err := func() error {
s.Queries = make([]jx.Raw, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem jx.Raw
v, err := d.RawAppend(nil)
elem = jx.Raw(v)
if err != nil {
return err
}
s.Queries = append(s.Queries, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"queries\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode DsQueryRequest")
}
// Validate required fields.
var failures []validate.FieldError
for i, mask := range [1]uint8{
0b00000100,
} {
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(jsonFieldsNameOfDsQueryRequest) {
name = jsonFieldsNameOfDsQueryRequest[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 *DsQueryRequest) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *DsQueryRequest) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *Folder) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *Folder) encodeFields(e *jx.Encoder) {
{
if s.ID.Set {
e.FieldStart("id")
s.ID.Encode(e)
}
}
{
if s.UID.Set {
e.FieldStart("uid")
s.UID.Encode(e)
}
}
{
if s.Title.Set {
e.FieldStart("title")
s.Title.Encode(e)
}
}
{
if s.URL.Set {
e.FieldStart("url")
s.URL.Encode(e)
}
}
{
if s.HasAcl.Set {
e.FieldStart("hasAcl")
s.HasAcl.Encode(e)
}
}
{
if s.CanSave.Set {
e.FieldStart("canSave")
s.CanSave.Encode(e)
}
}
{
if s.CanEdit.Set {
e.FieldStart("canEdit")
s.CanEdit.Encode(e)
}
}
{
if s.CanAdmin.Set {
e.FieldStart("canAdmin")
s.CanAdmin.Encode(e)
}
}
{
if s.CanDelete.Set {
e.FieldStart("canDelete")
s.CanDelete.Encode(e)
}
}
{
if s.CreatedBy.Set {
e.FieldStart("createdBy")
s.CreatedBy.Encode(e)
}
}
{
if s.Created.Set {
e.FieldStart("created")
s.Created.Encode(e)
}
}
{
if s.UpdatedBy.Set {
e.FieldStart("updatedBy")
s.UpdatedBy.Encode(e)
}
}
{
if s.Updated.Set {
e.FieldStart("updated")
s.Updated.Encode(e)
}
}
{
if s.Version.Set {
e.FieldStart("version")
s.Version.Encode(e)
}
}
{
if s.ParentUid.Set {
e.FieldStart("parentUid")
s.ParentUid.Encode(e)
}
}
}
var jsonFieldsNameOfFolder = [15]string{
0: "id",
1: "uid",
2: "title",
3: "url",
4: "hasAcl",
5: "canSave",
6: "canEdit",
7: "canAdmin",
8: "canDelete",
9: "createdBy",
10: "created",
11: "updatedBy",
12: "updated",
13: "version",
14: "parentUid",
}
// Decode decodes Folder from json.
func (s *Folder) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode Folder to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "id":
if err := func() error {
s.ID.Reset()
if err := s.ID.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"id\"")
}
case "uid":
if err := func() error {
s.UID.Reset()
if err := s.UID.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"uid\"")
}
case "title":
if err := func() error {
s.Title.Reset()
if err := s.Title.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"title\"")
}
case "url":
if err := func() error {
s.URL.Reset()
if err := s.URL.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"url\"")
}
case "hasAcl":
if err := func() error {
s.HasAcl.Reset()
if err := s.HasAcl.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"hasAcl\"")
}
case "canSave":
if err := func() error {
s.CanSave.Reset()
if err := s.CanSave.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"canSave\"")
}
case "canEdit":
if err := func() error {
s.CanEdit.Reset()
if err := s.CanEdit.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"canEdit\"")
}
case "canAdmin":
if err := func() error {
s.CanAdmin.Reset()
if err := s.CanAdmin.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"canAdmin\"")
}
case "canDelete":
if err := func() error {
s.CanDelete.Reset()
if err := s.CanDelete.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"canDelete\"")
}
case "createdBy":
if err := func() error {
s.CreatedBy.Reset()
if err := s.CreatedBy.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"createdBy\"")
}
case "created":
if err := func() error {
s.Created.Reset()
if err := s.Created.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"created\"")
}
case "updatedBy":
if err := func() error {
s.UpdatedBy.Reset()
if err := s.UpdatedBy.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"updatedBy\"")
}
case "updated":
if err := func() error {
s.Updated.Reset()
if err := s.Updated.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"updated\"")
}
case "version":
if err := func() error {
s.Version.Reset()
if err := s.Version.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"version\"")
}
case "parentUid":
if err := func() error {
s.ParentUid.Reset()
if err := s.ParentUid.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"parentUid\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode Folder")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *Folder) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Folder) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *NotificationPolicy) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *NotificationPolicy) encodeFields(e *jx.Encoder) {
{
if s.Receiver.Set {
e.FieldStart("receiver")
s.Receiver.Encode(e)
}
}
{
if s.GroupBy != nil {
e.FieldStart("group_by")
e.ArrStart()
for _, elem := range s.GroupBy {
e.Str(elem)
}
e.ArrEnd()
}
}
{
if s.Routes != nil {
e.FieldStart("routes")
e.ArrStart()
for _, elem := range s.Routes {
if len(elem) != 0 {
e.Raw(elem)
}
}
e.ArrEnd()
}
}
{
if s.GroupWait.Set {
e.FieldStart("group_wait")
s.GroupWait.Encode(e)
}
}
{
if s.GroupInterval.Set {
e.FieldStart("group_interval")
s.GroupInterval.Encode(e)
}
}
{
if s.RepeatInterval.Set {
e.FieldStart("repeat_interval")
s.RepeatInterval.Encode(e)
}
}
{
if s.Provenance.Set {
e.FieldStart("provenance")
s.Provenance.Encode(e)
}
}
}
var jsonFieldsNameOfNotificationPolicy = [7]string{
0: "receiver",
1: "group_by",
2: "routes",
3: "group_wait",
4: "group_interval",
5: "repeat_interval",
6: "provenance",
}
// Decode decodes NotificationPolicy from json.
func (s *NotificationPolicy) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode NotificationPolicy to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "receiver":
if err := func() error {
s.Receiver.Reset()
if err := s.Receiver.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"receiver\"")
}
case "group_by":
if err := func() error {
s.GroupBy = 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.GroupBy = append(s.GroupBy, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"group_by\"")
}
case "routes":
if err := func() error {
s.Routes = make([]jx.Raw, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem jx.Raw
v, err := d.RawAppend(nil)
elem = jx.Raw(v)
if err != nil {
return err
}
s.Routes = append(s.Routes, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"routes\"")
}
case "group_wait":
if err := func() error {
s.GroupWait.Reset()
if err := s.GroupWait.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"group_wait\"")
}
case "group_interval":
if err := func() error {
s.GroupInterval.Reset()
if err := s.GroupInterval.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"group_interval\"")
}
case "repeat_interval":
if err := func() error {
s.RepeatInterval.Reset()
if err := s.RepeatInterval.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"repeat_interval\"")
}
case "provenance":
if err := func() error {
s.Provenance.Reset()
if err := s.Provenance.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"provenance\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode NotificationPolicy")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *NotificationPolicy) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *NotificationPolicy) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes bool as json.
func (o OptBool) Encode(e *jx.Encoder) {
if !o.Set {
return
}
e.Bool(bool(o.Value))
}
// Decode decodes bool from json.
func (o *OptBool) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptBool to nil")
}
o.Set = true
v, err := d.Bool()
if err != nil {
return err
}
o.Value = bool(v)
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptBool) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptBool) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes DashboardMeta as json.
func (o OptDashboardMeta) Encode(e *jx.Encoder) {
if !o.Set {
return
}
o.Value.Encode(e)
}
// Decode decodes DashboardMeta from json.
func (o *OptDashboardMeta) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptDashboardMeta to nil")
}
o.Set = true
if err := o.Value.Decode(d); err != nil {
return err
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptDashboardMeta) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptDashboardMeta) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes int as json.
func (o OptInt) Encode(e *jx.Encoder) {
if !o.Set {
return
}
e.Int(int(o.Value))
}
// Decode decodes int from json.
func (o *OptInt) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptInt to nil")
}
o.Set = true
v, err := d.Int()
if err != nil {
return err
}
o.Value = int(v)
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptInt) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptInt) 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 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 implements json.Marshaler.
func (s *SaveDashboardRequest) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *SaveDashboardRequest) encodeFields(e *jx.Encoder) {
{
if len(s.Dashboard) != 0 {
e.FieldStart("dashboard")
e.Raw(s.Dashboard)
}
}
{
if s.FolderId.Set {
e.FieldStart("folderId")
s.FolderId.Encode(e)
}
}
{
if s.FolderUid.Set {
e.FieldStart("folderUid")
s.FolderUid.Encode(e)
}
}
{
if s.Message.Set {
e.FieldStart("message")
s.Message.Encode(e)
}
}
{
if s.Overwrite.Set {
e.FieldStart("overwrite")
s.Overwrite.Encode(e)
}
}
}
var jsonFieldsNameOfSaveDashboardRequest = [5]string{
0: "dashboard",
1: "folderId",
2: "folderUid",
3: "message",
4: "overwrite",
}
// Decode decodes SaveDashboardRequest from json.
func (s *SaveDashboardRequest) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode SaveDashboardRequest to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "dashboard":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.RawAppend(nil)
s.Dashboard = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"dashboard\"")
}
case "folderId":
if err := func() error {
s.FolderId.Reset()
if err := s.FolderId.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"folderId\"")
}
case "folderUid":
if err := func() error {
s.FolderUid.Reset()
if err := s.FolderUid.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"folderUid\"")
}
case "message":
if err := func() error {
s.Message.Reset()
if err := s.Message.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"message\"")
}
case "overwrite":
if err := func() error {
s.Overwrite.Reset()
if err := s.Overwrite.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"overwrite\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode SaveDashboardRequest")
}
// Validate required fields.
var failures []validate.FieldError
for i, mask := range [1]uint8{
0b00000001,
} {
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(jsonFieldsNameOfSaveDashboardRequest) {
name = jsonFieldsNameOfSaveDashboardRequest[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 *SaveDashboardRequest) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SaveDashboardRequest) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *SaveDashboardResponse) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *SaveDashboardResponse) encodeFields(e *jx.Encoder) {
{
if s.ID.Set {
e.FieldStart("id")
s.ID.Encode(e)
}
}
{
if s.UID.Set {
e.FieldStart("uid")
s.UID.Encode(e)
}
}
{
if s.URL.Set {
e.FieldStart("url")
s.URL.Encode(e)
}
}
{
if s.Status.Set {
e.FieldStart("status")
s.Status.Encode(e)
}
}
{
if s.Version.Set {
e.FieldStart("version")
s.Version.Encode(e)
}
}
{
if s.Slug.Set {
e.FieldStart("slug")
s.Slug.Encode(e)
}
}
}
var jsonFieldsNameOfSaveDashboardResponse = [6]string{
0: "id",
1: "uid",
2: "url",
3: "status",
4: "version",
5: "slug",
}
// Decode decodes SaveDashboardResponse from json.
func (s *SaveDashboardResponse) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode SaveDashboardResponse to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "id":
if err := func() error {
s.ID.Reset()
if err := s.ID.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"id\"")
}
case "uid":
if err := func() error {
s.UID.Reset()
if err := s.UID.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"uid\"")
}
case "url":
if err := func() error {
s.URL.Reset()
if err := s.URL.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"url\"")
}
case "status":
if err := func() error {
s.Status.Reset()
if err := s.Status.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"status\"")
}
case "version":
if err := func() error {
s.Version.Reset()
if err := s.Version.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"version\"")
}
case "slug":
if err := func() error {
s.Slug.Reset()
if err := s.Slug.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"slug\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode SaveDashboardResponse")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *SaveDashboardResponse) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SaveDashboardResponse) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *SearchResult) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *SearchResult) encodeFields(e *jx.Encoder) {
{
if s.ID.Set {
e.FieldStart("id")
s.ID.Encode(e)
}
}
{
if s.UID.Set {
e.FieldStart("uid")
s.UID.Encode(e)
}
}
{
if s.Title.Set {
e.FieldStart("title")
s.Title.Encode(e)
}
}
{
if s.URI.Set {
e.FieldStart("uri")
s.URI.Encode(e)
}
}
{
if s.URL.Set {
e.FieldStart("url")
s.URL.Encode(e)
}
}
{
if s.Slug.Set {
e.FieldStart("slug")
s.Slug.Encode(e)
}
}
{
if s.Type.Set {
e.FieldStart("type")
s.Type.Encode(e)
}
}
{
if s.Tags != nil {
e.FieldStart("tags")
e.ArrStart()
for _, elem := range s.Tags {
e.Str(elem)
}
e.ArrEnd()
}
}
{
if s.IsStarred.Set {
e.FieldStart("isStarred")
s.IsStarred.Encode(e)
}
}
{
if s.FolderUid.Set {
e.FieldStart("folderUid")
s.FolderUid.Encode(e)
}
}
{
if s.FolderTitle.Set {
e.FieldStart("folderTitle")
s.FolderTitle.Encode(e)
}
}
{
if s.FolderUrl.Set {
e.FieldStart("folderUrl")
s.FolderUrl.Encode(e)
}
}
}
var jsonFieldsNameOfSearchResult = [12]string{
0: "id",
1: "uid",
2: "title",
3: "uri",
4: "url",
5: "slug",
6: "type",
7: "tags",
8: "isStarred",
9: "folderUid",
10: "folderTitle",
11: "folderUrl",
}
// Decode decodes SearchResult from json.
func (s *SearchResult) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode SearchResult to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "id":
if err := func() error {
s.ID.Reset()
if err := s.ID.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"id\"")
}
case "uid":
if err := func() error {
s.UID.Reset()
if err := s.UID.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"uid\"")
}
case "title":
if err := func() error {
s.Title.Reset()
if err := s.Title.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"title\"")
}
case "uri":
if err := func() error {
s.URI.Reset()
if err := s.URI.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"uri\"")
}
case "url":
if err := func() error {
s.URL.Reset()
if err := s.URL.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"url\"")
}
case "slug":
if err := func() error {
s.Slug.Reset()
if err := s.Slug.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"slug\"")
}
case "type":
if err := func() error {
s.Type.Reset()
if err := s.Type.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"type\"")
}
case "tags":
if err := func() error {
s.Tags = 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.Tags = append(s.Tags, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"tags\"")
}
case "isStarred":
if err := func() error {
s.IsStarred.Reset()
if err := s.IsStarred.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"isStarred\"")
}
case "folderUid":
if err := func() error {
s.FolderUid.Reset()
if err := s.FolderUid.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"folderUid\"")
}
case "folderTitle":
if err := func() error {
s.FolderTitle.Reset()
if err := s.FolderTitle.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"folderTitle\"")
}
case "folderUrl":
if err := func() error {
s.FolderUrl.Reset()
if err := s.FolderUrl.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"folderUrl\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode SearchResult")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *SearchResult) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SearchResult) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *UpdateContactPointRequest) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *UpdateContactPointRequest) encodeFields(e *jx.Encoder) {
{
e.FieldStart("name")
e.Str(s.Name)
}
{
e.FieldStart("type")
e.Str(s.Type)
}
{
if len(s.Settings) != 0 {
e.FieldStart("settings")
e.Raw(s.Settings)
}
}
{
if s.DisableResolveMessage.Set {
e.FieldStart("disableResolveMessage")
s.DisableResolveMessage.Encode(e)
}
}
}
var jsonFieldsNameOfUpdateContactPointRequest = [4]string{
0: "name",
1: "type",
2: "settings",
3: "disableResolveMessage",
}
// Decode decodes UpdateContactPointRequest from json.
func (s *UpdateContactPointRequest) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode UpdateContactPointRequest to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "name":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Str()
s.Name = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"name\"")
}
case "type":
requiredBitSet[0] |= 1 << 1
if err := func() error {
v, err := d.Str()
s.Type = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"type\"")
}
case "settings":
requiredBitSet[0] |= 1 << 2
if err := func() error {
v, err := d.RawAppend(nil)
s.Settings = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"settings\"")
}
case "disableResolveMessage":
if err := func() error {
s.DisableResolveMessage.Reset()
if err := s.DisableResolveMessage.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"disableResolveMessage\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode UpdateContactPointRequest")
}
// 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(jsonFieldsNameOfUpdateContactPointRequest) {
name = jsonFieldsNameOfUpdateContactPointRequest[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 *UpdateContactPointRequest) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UpdateContactPointRequest) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
