// 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 *AddCommentRequest) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *AddCommentRequest) encodeFields(e *jx.Encoder) {
{
if len(s.Body) != 0 {
e.FieldStart("body")
e.Raw(s.Body)
}
}
}
var jsonFieldsNameOfAddCommentRequest = [1]string{
0: "body",
}
// Decode decodes AddCommentRequest from json.
func (s *AddCommentRequest) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode AddCommentRequest to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "body":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.RawAppend(nil)
s.Body = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"body\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode AddCommentRequest")
}
// 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(jsonFieldsNameOfAddCommentRequest) {
name = jsonFieldsNameOfAddCommentRequest[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 *AddCommentRequest) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AddCommentRequest) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *Comment) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *Comment) encodeFields(e *jx.Encoder) {
{
if s.ID.Set {
e.FieldStart("id")
s.ID.Encode(e)
}
}
{
if s.Self.Set {
e.FieldStart("self")
s.Self.Encode(e)
}
}
{
if len(s.Author) != 0 {
e.FieldStart("author")
e.Raw(s.Author)
}
}
{
if len(s.Body) != 0 {
e.FieldStart("body")
e.Raw(s.Body)
}
}
{
if s.Created.Set {
e.FieldStart("created")
s.Created.Encode(e)
}
}
{
if s.Updated.Set {
e.FieldStart("updated")
s.Updated.Encode(e)
}
}
}
var jsonFieldsNameOfComment = [6]string{
0: "id",
1: "self",
2: "author",
3: "body",
4: "created",
5: "updated",
}
// Decode decodes Comment from json.
func (s *Comment) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode Comment 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 "self":
if err := func() error {
s.Self.Reset()
if err := s.Self.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"self\"")
}
case "author":
if err := func() error {
v, err := d.RawAppend(nil)
s.Author = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"author\"")
}
case "body":
if err := func() error {
v, err := d.RawAppend(nil)
s.Body = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"body\"")
}
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\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode Comment")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *Comment) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Comment) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *CommentSearchResult) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *CommentSearchResult) encodeFields(e *jx.Encoder) {
{
if s.Comments != nil {
e.FieldStart("comments")
e.ArrStart()
for _, elem := range s.Comments {
elem.Encode(e)
}
e.ArrEnd()
}
}
{
if s.MaxResults.Set {
e.FieldStart("maxResults")
s.MaxResults.Encode(e)
}
}
{
if s.StartAt.Set {
e.FieldStart("startAt")
s.StartAt.Encode(e)
}
}
{
if s.Total.Set {
e.FieldStart("total")
s.Total.Encode(e)
}
}
}
var jsonFieldsNameOfCommentSearchResult = [4]string{
0: "comments",
1: "maxResults",
2: "startAt",
3: "total",
}
// Decode decodes CommentSearchResult from json.
func (s *CommentSearchResult) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode CommentSearchResult to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "comments":
if err := func() error {
s.Comments = make([]Comment, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem Comment
if err := elem.Decode(d); err != nil {
return err
}
s.Comments = append(s.Comments, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"comments\"")
}
case "maxResults":
if err := func() error {
s.MaxResults.Reset()
if err := s.MaxResults.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"maxResults\"")
}
case "startAt":
if err := func() error {
s.StartAt.Reset()
if err := s.StartAt.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"startAt\"")
}
case "total":
if err := func() error {
s.Total.Reset()
if err := s.Total.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"total\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode CommentSearchResult")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *CommentSearchResult) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CommentSearchResult) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *CreateIssueRequest) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *CreateIssueRequest) encodeFields(e *jx.Encoder) {
{
e.FieldStart("fields")
s.Fields.Encode(e)
}
}
var jsonFieldsNameOfCreateIssueRequest = [1]string{
0: "fields",
}
// Decode decodes CreateIssueRequest from json.
func (s *CreateIssueRequest) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode CreateIssueRequest to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "fields":
requiredBitSet[0] |= 1 << 0
if err := func() error {
if err := s.Fields.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"fields\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode CreateIssueRequest")
}
// 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(jsonFieldsNameOfCreateIssueRequest) {
name = jsonFieldsNameOfCreateIssueRequest[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 *CreateIssueRequest) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CreateIssueRequest) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *CreatedIssue) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *CreatedIssue) encodeFields(e *jx.Encoder) {
{
if s.ID.Set {
e.FieldStart("id")
s.ID.Encode(e)
}
}
{
if s.Key.Set {
e.FieldStart("key")
s.Key.Encode(e)
}
}
{
if s.Self.Set {
e.FieldStart("self")
s.Self.Encode(e)
}
}
}
var jsonFieldsNameOfCreatedIssue = [3]string{
0: "id",
1: "key",
2: "self",
}
// Decode decodes CreatedIssue from json.
func (s *CreatedIssue) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode CreatedIssue 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 "key":
if err := func() error {
s.Key.Reset()
if err := s.Key.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"key\"")
}
case "self":
if err := func() error {
s.Self.Reset()
if err := s.Self.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"self\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode CreatedIssue")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *CreatedIssue) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CreatedIssue) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *DoTransitionRequest) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *DoTransitionRequest) encodeFields(e *jx.Encoder) {
{
e.FieldStart("transition")
s.Transition.Encode(e)
}
{
if len(s.Update) != 0 {
e.FieldStart("update")
e.Raw(s.Update)
}
}
}
var jsonFieldsNameOfDoTransitionRequest = [2]string{
0: "transition",
1: "update",
}
// Decode decodes DoTransitionRequest from json.
func (s *DoTransitionRequest) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode DoTransitionRequest to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "transition":
requiredBitSet[0] |= 1 << 0
if err := func() error {
if err := s.Transition.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"transition\"")
}
case "update":
if err := func() error {
v, err := d.RawAppend(nil)
s.Update = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"update\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode DoTransitionRequest")
}
// 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(jsonFieldsNameOfDoTransitionRequest) {
name = jsonFieldsNameOfDoTransitionRequest[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 *DoTransitionRequest) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *DoTransitionRequest) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *Issue) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *Issue) encodeFields(e *jx.Encoder) {
{
if s.ID.Set {
e.FieldStart("id")
s.ID.Encode(e)
}
}
{
if s.Key.Set {
e.FieldStart("key")
s.Key.Encode(e)
}
}
{
if s.Self.Set {
e.FieldStart("self")
s.Self.Encode(e)
}
}
{
if len(s.Fields) != 0 {
e.FieldStart("fields")
e.Raw(s.Fields)
}
}
}
var jsonFieldsNameOfIssue = [4]string{
0: "id",
1: "key",
2: "self",
3: "fields",
}
// Decode decodes Issue from json.
func (s *Issue) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode Issue 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 "key":
if err := func() error {
s.Key.Reset()
if err := s.Key.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"key\"")
}
case "self":
if err := func() error {
s.Self.Reset()
if err := s.Self.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"self\"")
}
case "fields":
if err := func() error {
v, err := d.RawAppend(nil)
s.Fields = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"fields\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode Issue")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *Issue) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Issue) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *IssueFields) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *IssueFields) encodeFields(e *jx.Encoder) {
{
if len(s.Project) != 0 {
e.FieldStart("project")
e.Raw(s.Project)
}
}
{
if len(s.Issuetype) != 0 {
e.FieldStart("issuetype")
e.Raw(s.Issuetype)
}
}
{
if s.Summary.Set {
e.FieldStart("summary")
s.Summary.Encode(e)
}
}
{
if len(s.Description) != 0 {
e.FieldStart("description")
e.Raw(s.Description)
}
}
{
if len(s.Assignee) != 0 {
e.FieldStart("assignee")
e.Raw(s.Assignee)
}
}
{
if len(s.Priority) != 0 {
e.FieldStart("priority")
e.Raw(s.Priority)
}
}
{
if s.Labels != nil {
e.FieldStart("labels")
e.ArrStart()
for _, elem := range s.Labels {
e.Str(elem)
}
e.ArrEnd()
}
}
{
if len(s.Parent) != 0 {
e.FieldStart("parent")
e.Raw(s.Parent)
}
}
}
var jsonFieldsNameOfIssueFields = [8]string{
0: "project",
1: "issuetype",
2: "summary",
3: "description",
4: "assignee",
5: "priority",
6: "labels",
7: "parent",
}
// Decode decodes IssueFields from json.
func (s *IssueFields) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode IssueFields to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "project":
if err := func() error {
v, err := d.RawAppend(nil)
s.Project = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"project\"")
}
case "issuetype":
if err := func() error {
v, err := d.RawAppend(nil)
s.Issuetype = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"issuetype\"")
}
case "summary":
if err := func() error {
s.Summary.Reset()
if err := s.Summary.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"summary\"")
}
case "description":
if err := func() error {
v, err := d.RawAppend(nil)
s.Description = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"description\"")
}
case "assignee":
if err := func() error {
v, err := d.RawAppend(nil)
s.Assignee = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"assignee\"")
}
case "priority":
if err := func() error {
v, err := d.RawAppend(nil)
s.Priority = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"priority\"")
}
case "labels":
if err := func() error {
s.Labels = 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.Labels = append(s.Labels, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"labels\"")
}
case "parent":
if err := func() error {
v, err := d.RawAppend(nil)
s.Parent = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"parent\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode IssueFields")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *IssueFields) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *IssueFields) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *IssueSearchResult) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *IssueSearchResult) encodeFields(e *jx.Encoder) {
{
if s.Issues != nil {
e.FieldStart("issues")
e.ArrStart()
for _, elem := range s.Issues {
elem.Encode(e)
}
e.ArrEnd()
}
}
{
if s.MaxResults.Set {
e.FieldStart("maxResults")
s.MaxResults.Encode(e)
}
}
{
if s.StartAt.Set {
e.FieldStart("startAt")
s.StartAt.Encode(e)
}
}
{
if s.Total.Set {
e.FieldStart("total")
s.Total.Encode(e)
}
}
}
var jsonFieldsNameOfIssueSearchResult = [4]string{
0: "issues",
1: "maxResults",
2: "startAt",
3: "total",
}
// Decode decodes IssueSearchResult from json.
func (s *IssueSearchResult) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode IssueSearchResult to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "issues":
if err := func() error {
s.Issues = make([]Issue, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem Issue
if err := elem.Decode(d); err != nil {
return err
}
s.Issues = append(s.Issues, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"issues\"")
}
case "maxResults":
if err := func() error {
s.MaxResults.Reset()
if err := s.MaxResults.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"maxResults\"")
}
case "startAt":
if err := func() error {
s.StartAt.Reset()
if err := s.StartAt.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"startAt\"")
}
case "total":
if err := func() error {
s.Total.Reset()
if err := s.Total.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"total\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode IssueSearchResult")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *IssueSearchResult) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *IssueSearchResult) 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 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 IssueFields as json.
func (o OptIssueFields) Encode(e *jx.Encoder) {
if !o.Set {
return
}
o.Value.Encode(e)
}
// Decode decodes IssueFields from json.
func (o *OptIssueFields) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptIssueFields to nil")
}
o.Set = true
if err := o.Value.Decode(d); err != nil {
return err
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptIssueFields) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptIssueFields) 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 *Project) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *Project) encodeFields(e *jx.Encoder) {
{
if s.ID.Set {
e.FieldStart("id")
s.ID.Encode(e)
}
}
{
if s.Key.Set {
e.FieldStart("key")
s.Key.Encode(e)
}
}
{
if s.Name.Set {
e.FieldStart("name")
s.Name.Encode(e)
}
}
{
if s.ProjectTypeKey.Set {
e.FieldStart("projectTypeKey")
s.ProjectTypeKey.Encode(e)
}
}
{
if s.Simplified.Set {
e.FieldStart("simplified")
s.Simplified.Encode(e)
}
}
{
if s.Style.Set {
e.FieldStart("style")
s.Style.Encode(e)
}
}
{
if s.IsPrivate.Set {
e.FieldStart("isPrivate")
s.IsPrivate.Encode(e)
}
}
{
if s.Description.Set {
e.FieldStart("description")
s.Description.Encode(e)
}
}
{
if len(s.Lead) != 0 {
e.FieldStart("lead")
e.Raw(s.Lead)
}
}
{
if len(s.AvatarUrls) != 0 {
e.FieldStart("avatarUrls")
e.Raw(s.AvatarUrls)
}
}
}
var jsonFieldsNameOfProject = [10]string{
0: "id",
1: "key",
2: "name",
3: "projectTypeKey",
4: "simplified",
5: "style",
6: "isPrivate",
7: "description",
8: "lead",
9: "avatarUrls",
}
// Decode decodes Project from json.
func (s *Project) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode Project 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 "key":
if err := func() error {
s.Key.Reset()
if err := s.Key.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"key\"")
}
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 "projectTypeKey":
if err := func() error {
s.ProjectTypeKey.Reset()
if err := s.ProjectTypeKey.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"projectTypeKey\"")
}
case "simplified":
if err := func() error {
s.Simplified.Reset()
if err := s.Simplified.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"simplified\"")
}
case "style":
if err := func() error {
s.Style.Reset()
if err := s.Style.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"style\"")
}
case "isPrivate":
if err := func() error {
s.IsPrivate.Reset()
if err := s.IsPrivate.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"isPrivate\"")
}
case "description":
if err := func() error {
s.Description.Reset()
if err := s.Description.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"description\"")
}
case "lead":
if err := func() error {
v, err := d.RawAppend(nil)
s.Lead = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"lead\"")
}
case "avatarUrls":
if err := func() error {
v, err := d.RawAppend(nil)
s.AvatarUrls = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"avatarUrls\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode Project")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *Project) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Project) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *ProjectSearchResult) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *ProjectSearchResult) encodeFields(e *jx.Encoder) {
{
if s.Values != nil {
e.FieldStart("values")
e.ArrStart()
for _, elem := range s.Values {
elem.Encode(e)
}
e.ArrEnd()
}
}
{
if s.MaxResults.Set {
e.FieldStart("maxResults")
s.MaxResults.Encode(e)
}
}
{
if s.StartAt.Set {
e.FieldStart("startAt")
s.StartAt.Encode(e)
}
}
{
if s.Total.Set {
e.FieldStart("total")
s.Total.Encode(e)
}
}
{
if s.IsLast.Set {
e.FieldStart("isLast")
s.IsLast.Encode(e)
}
}
}
var jsonFieldsNameOfProjectSearchResult = [5]string{
0: "values",
1: "maxResults",
2: "startAt",
3: "total",
4: "isLast",
}
// Decode decodes ProjectSearchResult from json.
func (s *ProjectSearchResult) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode ProjectSearchResult 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([]Project, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem Project
if err := elem.Decode(d); 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 "maxResults":
if err := func() error {
s.MaxResults.Reset()
if err := s.MaxResults.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"maxResults\"")
}
case "startAt":
if err := func() error {
s.StartAt.Reset()
if err := s.StartAt.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"startAt\"")
}
case "total":
if err := func() error {
s.Total.Reset()
if err := s.Total.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"total\"")
}
case "isLast":
if err := func() error {
s.IsLast.Reset()
if err := s.IsLast.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"isLast\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode ProjectSearchResult")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *ProjectSearchResult) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ProjectSearchResult) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *Transition) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *Transition) encodeFields(e *jx.Encoder) {
{
if s.ID.Set {
e.FieldStart("id")
s.ID.Encode(e)
}
}
{
if s.Name.Set {
e.FieldStart("name")
s.Name.Encode(e)
}
}
{
if len(s.To) != 0 {
e.FieldStart("to")
e.Raw(s.To)
}
}
{
if s.HasScreen.Set {
e.FieldStart("hasScreen")
s.HasScreen.Encode(e)
}
}
{
if s.IsGlobal.Set {
e.FieldStart("isGlobal")
s.IsGlobal.Encode(e)
}
}
{
if s.IsInitial.Set {
e.FieldStart("isInitial")
s.IsInitial.Encode(e)
}
}
{
if s.IsAvailable.Set {
e.FieldStart("isAvailable")
s.IsAvailable.Encode(e)
}
}
{
if s.IsConditional.Set {
e.FieldStart("isConditional")
s.IsConditional.Encode(e)
}
}
{
if s.IsLooped.Set {
e.FieldStart("isLooped")
s.IsLooped.Encode(e)
}
}
}
var jsonFieldsNameOfTransition = [9]string{
0: "id",
1: "name",
2: "to",
3: "hasScreen",
4: "isGlobal",
5: "isInitial",
6: "isAvailable",
7: "isConditional",
8: "isLooped",
}
// Decode decodes Transition from json.
func (s *Transition) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode Transition 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 "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 "to":
if err := func() error {
v, err := d.RawAppend(nil)
s.To = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"to\"")
}
case "hasScreen":
if err := func() error {
s.HasScreen.Reset()
if err := s.HasScreen.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"hasScreen\"")
}
case "isGlobal":
if err := func() error {
s.IsGlobal.Reset()
if err := s.IsGlobal.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"isGlobal\"")
}
case "isInitial":
if err := func() error {
s.IsInitial.Reset()
if err := s.IsInitial.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"isInitial\"")
}
case "isAvailable":
if err := func() error {
s.IsAvailable.Reset()
if err := s.IsAvailable.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"isAvailable\"")
}
case "isConditional":
if err := func() error {
s.IsConditional.Reset()
if err := s.IsConditional.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"isConditional\"")
}
case "isLooped":
if err := func() error {
s.IsLooped.Reset()
if err := s.IsLooped.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"isLooped\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode Transition")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *Transition) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Transition) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *TransitionRef) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *TransitionRef) encodeFields(e *jx.Encoder) {
{
e.FieldStart("id")
e.Str(s.ID)
}
}
var jsonFieldsNameOfTransitionRef = [1]string{
0: "id",
}
// Decode decodes TransitionRef from json.
func (s *TransitionRef) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode TransitionRef to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "id":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Str()
s.ID = string(v)
if 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 TransitionRef")
}
// 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(jsonFieldsNameOfTransitionRef) {
name = jsonFieldsNameOfTransitionRef[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 *TransitionRef) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *TransitionRef) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *TransitionsResponse) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *TransitionsResponse) encodeFields(e *jx.Encoder) {
{
if s.Transitions != nil {
e.FieldStart("transitions")
e.ArrStart()
for _, elem := range s.Transitions {
elem.Encode(e)
}
e.ArrEnd()
}
}
}
var jsonFieldsNameOfTransitionsResponse = [1]string{
0: "transitions",
}
// Decode decodes TransitionsResponse from json.
func (s *TransitionsResponse) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode TransitionsResponse to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "transitions":
if err := func() error {
s.Transitions = make([]Transition, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem Transition
if err := elem.Decode(d); err != nil {
return err
}
s.Transitions = append(s.Transitions, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"transitions\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode TransitionsResponse")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *TransitionsResponse) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *TransitionsResponse) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *UpdateIssueRequest) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *UpdateIssueRequest) encodeFields(e *jx.Encoder) {
{
if s.Fields.Set {
e.FieldStart("fields")
s.Fields.Encode(e)
}
}
}
var jsonFieldsNameOfUpdateIssueRequest = [1]string{
0: "fields",
}
// Decode decodes UpdateIssueRequest from json.
func (s *UpdateIssueRequest) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode UpdateIssueRequest to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "fields":
if err := func() error {
s.Fields.Reset()
if err := s.Fields.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"fields\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode UpdateIssueRequest")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *UpdateIssueRequest) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UpdateIssueRequest) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *User) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *User) encodeFields(e *jx.Encoder) {
{
if s.AccountId.Set {
e.FieldStart("accountId")
s.AccountId.Encode(e)
}
}
{
if s.EmailAddress.Set {
e.FieldStart("emailAddress")
s.EmailAddress.Encode(e)
}
}
{
if s.DisplayName.Set {
e.FieldStart("displayName")
s.DisplayName.Encode(e)
}
}
{
if s.Active.Set {
e.FieldStart("active")
s.Active.Encode(e)
}
}
{
if s.TimeZone.Set {
e.FieldStart("timeZone")
s.TimeZone.Encode(e)
}
}
{
if s.Locale.Set {
e.FieldStart("locale")
s.Locale.Encode(e)
}
}
{
if len(s.AvatarUrls) != 0 {
e.FieldStart("avatarUrls")
e.Raw(s.AvatarUrls)
}
}
}
var jsonFieldsNameOfUser = [7]string{
0: "accountId",
1: "emailAddress",
2: "displayName",
3: "active",
4: "timeZone",
5: "locale",
6: "avatarUrls",
}
// Decode decodes User from json.
func (s *User) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode User to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "accountId":
if err := func() error {
s.AccountId.Reset()
if err := s.AccountId.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"accountId\"")
}
case "emailAddress":
if err := func() error {
s.EmailAddress.Reset()
if err := s.EmailAddress.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"emailAddress\"")
}
case "displayName":
if err := func() error {
s.DisplayName.Reset()
if err := s.DisplayName.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"displayName\"")
}
case "active":
if err := func() error {
s.Active.Reset()
if err := s.Active.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"active\"")
}
case "timeZone":
if err := func() error {
s.TimeZone.Reset()
if err := s.TimeZone.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"timeZone\"")
}
case "locale":
if err := func() error {
s.Locale.Reset()
if err := s.Locale.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"locale\"")
}
case "avatarUrls":
if err := func() error {
v, err := d.RawAppend(nil)
s.AvatarUrls = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"avatarUrls\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode User")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *User) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *User) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
