// Code generated by ogen, DO NOT EDIT.
package gen
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 *AddLabelRequest) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *AddLabelRequest) encodeFields(e *jx.Encoder) {
{
e.FieldStart("name")
e.Str(s.Name)
}
}
var jsonFieldsNameOfAddLabelRequest = [1]string{
0: "name",
}
// Decode decodes AddLabelRequest from json.
func (s *AddLabelRequest) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode AddLabelRequest 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\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode AddLabelRequest")
}
// 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(jsonFieldsNameOfAddLabelRequest) {
name = jsonFieldsNameOfAddLabelRequest[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 *AddLabelRequest) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AddLabelRequest) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes AddLabelRequestArray as json.
func (s AddLabelRequestArray) Encode(e *jx.Encoder) {
unwrapped := []AddLabelRequest(s)
e.ArrStart()
for _, elem := range unwrapped {
elem.Encode(e)
}
e.ArrEnd()
}
// Decode decodes AddLabelRequestArray from json.
func (s *AddLabelRequestArray) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode AddLabelRequestArray to nil")
}
var unwrapped []AddLabelRequest
if err := func() error {
unwrapped = make([]AddLabelRequest, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem AddLabelRequest
if err := elem.Decode(d); err != nil {
return err
}
unwrapped = append(unwrapped, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "alias")
}
*s = AddLabelRequestArray(unwrapped)
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s AddLabelRequestArray) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AddLabelRequestArray) 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.Status.Set {
e.FieldStart("status")
s.Status.Encode(e)
}
}
{
if s.Title.Set {
e.FieldStart("title")
s.Title.Encode(e)
}
}
{
if s.PageId.Set {
e.FieldStart("pageId")
s.PageId.Encode(e)
}
}
{
if len(s.Version) != 0 {
e.FieldStart("version")
e.Raw(s.Version)
}
}
{
if len(s.Body) != 0 {
e.FieldStart("body")
e.Raw(s.Body)
}
}
{
if len(s.Links) != 0 {
e.FieldStart("_links")
e.Raw(s.Links)
}
}
}
var jsonFieldsNameOfComment = [7]string{
0: "id",
1: "status",
2: "title",
3: "pageId",
4: "version",
5: "body",
6: "_links",
}
// 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 "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 "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 "pageId":
if err := func() error {
s.PageId.Reset()
if err := s.PageId.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"pageId\"")
}
case "version":
if err := func() error {
v, err := d.RawAppend(nil)
s.Version = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"version\"")
}
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 "_links":
if err := func() error {
v, err := d.RawAppend(nil)
s.Links = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"_links\"")
}
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 *CommentListResult) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *CommentListResult) encodeFields(e *jx.Encoder) {
{
if s.Results != nil {
e.FieldStart("results")
e.ArrStart()
for _, elem := range s.Results {
elem.Encode(e)
}
e.ArrEnd()
}
}
{
if len(s.Links) != 0 {
e.FieldStart("_links")
e.Raw(s.Links)
}
}
}
var jsonFieldsNameOfCommentListResult = [2]string{
0: "results",
1: "_links",
}
// Decode decodes CommentListResult from json.
func (s *CommentListResult) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode CommentListResult to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "results":
if err := func() error {
s.Results = 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.Results = append(s.Results, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"results\"")
}
case "_links":
if err := func() error {
v, err := d.RawAppend(nil)
s.Links = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"_links\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode CommentListResult")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *CommentListResult) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CommentListResult) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *CreateCommentRequest) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *CreateCommentRequest) encodeFields(e *jx.Encoder) {
{
e.FieldStart("pageId")
e.Str(s.PageId)
}
{
e.FieldStart("body")
s.Body.Encode(e)
}
}
var jsonFieldsNameOfCreateCommentRequest = [2]string{
0: "pageId",
1: "body",
}
// Decode decodes CreateCommentRequest from json.
func (s *CreateCommentRequest) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode CreateCommentRequest to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "pageId":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Str()
s.PageId = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"pageId\"")
}
case "body":
requiredBitSet[0] |= 1 << 1
if err := func() error {
if err := s.Body.Decode(d); 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 CreateCommentRequest")
}
// Validate required fields.
var failures []validate.FieldError
for i, mask := range [1]uint8{
0b00000011,
} {
if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
// Mask only required fields and check equality to mask using XOR.
//
// If XOR result is not zero, result is not equal to expected, so some fields are missed.
// Bits of fields which would be set are actually bits of missed fields.
missed := bits.OnesCount8(result)
for bitN := 0; bitN < missed; bitN++ {
bitIdx := bits.TrailingZeros8(result)
fieldIdx := i*8 + bitIdx
var name string
if fieldIdx < len(jsonFieldsNameOfCreateCommentRequest) {
name = jsonFieldsNameOfCreateCommentRequest[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 *CreateCommentRequest) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CreateCommentRequest) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *CreatePageRequest) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *CreatePageRequest) encodeFields(e *jx.Encoder) {
{
e.FieldStart("spaceId")
e.Str(s.SpaceId)
}
{
e.FieldStart("title")
e.Str(s.Title)
}
{
e.FieldStart("status")
e.Str(s.Status)
}
{
if s.ParentId.Set {
e.FieldStart("parentId")
s.ParentId.Encode(e)
}
}
{
e.FieldStart("body")
s.Body.Encode(e)
}
}
var jsonFieldsNameOfCreatePageRequest = [5]string{
0: "spaceId",
1: "title",
2: "status",
3: "parentId",
4: "body",
}
// Decode decodes CreatePageRequest from json.
func (s *CreatePageRequest) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode CreatePageRequest to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "spaceId":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Str()
s.SpaceId = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"spaceId\"")
}
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 "status":
requiredBitSet[0] |= 1 << 2
if err := func() error {
v, err := d.Str()
s.Status = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"status\"")
}
case "parentId":
if err := func() error {
s.ParentId.Reset()
if err := s.ParentId.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"parentId\"")
}
case "body":
requiredBitSet[0] |= 1 << 4
if err := func() error {
if err := s.Body.Decode(d); 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 CreatePageRequest")
}
// Validate required fields.
var failures []validate.FieldError
for i, mask := range [1]uint8{
0b00010111,
} {
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(jsonFieldsNameOfCreatePageRequest) {
name = jsonFieldsNameOfCreatePageRequest[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 *CreatePageRequest) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CreatePageRequest) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *Label) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *Label) 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 s.Prefix.Set {
e.FieldStart("prefix")
s.Prefix.Encode(e)
}
}
}
var jsonFieldsNameOfLabel = [3]string{
0: "id",
1: "name",
2: "prefix",
}
// Decode decodes Label from json.
func (s *Label) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode Label 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 "prefix":
if err := func() error {
s.Prefix.Reset()
if err := s.Prefix.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"prefix\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode Label")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *Label) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Label) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *LabelListResult) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *LabelListResult) encodeFields(e *jx.Encoder) {
{
if s.Results != nil {
e.FieldStart("results")
e.ArrStart()
for _, elem := range s.Results {
elem.Encode(e)
}
e.ArrEnd()
}
}
}
var jsonFieldsNameOfLabelListResult = [1]string{
0: "results",
}
// Decode decodes LabelListResult from json.
func (s *LabelListResult) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode LabelListResult to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "results":
if err := func() error {
s.Results = make([]Label, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem Label
if err := elem.Decode(d); err != nil {
return err
}
s.Results = append(s.Results, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"results\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode LabelListResult")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *LabelListResult) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *LabelListResult) 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 string as json.
func (o OptNilString) Encode(e *jx.Encoder) {
if !o.Set {
return
}
if o.Null {
e.Null()
return
}
e.Str(string(o.Value))
}
// Decode decodes string from json.
func (o *OptNilString) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptNilString to nil")
}
if d.Next() == jx.Null {
if err := d.Null(); err != nil {
return err
}
var v string
o.Value = v
o.Set = true
o.Null = true
return nil
}
o.Set = true
o.Null = false
v, err := d.Str()
if err != nil {
return err
}
o.Value = string(v)
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptNilString) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptNilString) 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 *Page) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *Page) encodeFields(e *jx.Encoder) {
{
if s.ID.Set {
e.FieldStart("id")
s.ID.Encode(e)
}
}
{
if s.Title.Set {
e.FieldStart("title")
s.Title.Encode(e)
}
}
{
if s.Status.Set {
e.FieldStart("status")
s.Status.Encode(e)
}
}
{
if s.SpaceId.Set {
e.FieldStart("spaceId")
s.SpaceId.Encode(e)
}
}
{
if s.ParentId.Set {
e.FieldStart("parentId")
s.ParentId.Encode(e)
}
}
{
if s.ParentType.Set {
e.FieldStart("parentType")
s.ParentType.Encode(e)
}
}
{
if s.Position.Set {
e.FieldStart("position")
s.Position.Encode(e)
}
}
{
if s.AuthorId.Set {
e.FieldStart("authorId")
s.AuthorId.Encode(e)
}
}
{
if s.OwnerId.Set {
e.FieldStart("ownerId")
s.OwnerId.Encode(e)
}
}
{
if s.CreatedAt.Set {
e.FieldStart("createdAt")
s.CreatedAt.Encode(e)
}
}
{
if len(s.Version) != 0 {
e.FieldStart("version")
e.Raw(s.Version)
}
}
{
if len(s.Body) != 0 {
e.FieldStart("body")
e.Raw(s.Body)
}
}
{
if len(s.Links) != 0 {
e.FieldStart("_links")
e.Raw(s.Links)
}
}
}
var jsonFieldsNameOfPage = [13]string{
0: "id",
1: "title",
2: "status",
3: "spaceId",
4: "parentId",
5: "parentType",
6: "position",
7: "authorId",
8: "ownerId",
9: "createdAt",
10: "version",
11: "body",
12: "_links",
}
// Decode decodes Page from json.
func (s *Page) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode Page 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 "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 "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 "spaceId":
if err := func() error {
s.SpaceId.Reset()
if err := s.SpaceId.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"spaceId\"")
}
case "parentId":
if err := func() error {
s.ParentId.Reset()
if err := s.ParentId.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"parentId\"")
}
case "parentType":
if err := func() error {
s.ParentType.Reset()
if err := s.ParentType.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"parentType\"")
}
case "position":
if err := func() error {
s.Position.Reset()
if err := s.Position.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"position\"")
}
case "authorId":
if err := func() error {
s.AuthorId.Reset()
if err := s.AuthorId.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"authorId\"")
}
case "ownerId":
if err := func() error {
s.OwnerId.Reset()
if err := s.OwnerId.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ownerId\"")
}
case "createdAt":
if err := func() error {
s.CreatedAt.Reset()
if err := s.CreatedAt.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"createdAt\"")
}
case "version":
if err := func() error {
v, err := d.RawAppend(nil)
s.Version = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"version\"")
}
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 "_links":
if err := func() error {
v, err := d.RawAppend(nil)
s.Links = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"_links\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode Page")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *Page) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Page) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *PageBody) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *PageBody) encodeFields(e *jx.Encoder) {
{
if s.Representation.Set {
e.FieldStart("representation")
s.Representation.Encode(e)
}
}
{
if s.Value.Set {
e.FieldStart("value")
s.Value.Encode(e)
}
}
}
var jsonFieldsNameOfPageBody = [2]string{
0: "representation",
1: "value",
}
// Decode decodes PageBody from json.
func (s *PageBody) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode PageBody to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "representation":
if err := func() error {
s.Representation.Reset()
if err := s.Representation.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"representation\"")
}
case "value":
if err := func() error {
s.Value.Reset()
if err := s.Value.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"value\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode PageBody")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *PageBody) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PageBody) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *PageListResult) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *PageListResult) encodeFields(e *jx.Encoder) {
{
if s.Results != nil {
e.FieldStart("results")
e.ArrStart()
for _, elem := range s.Results {
elem.Encode(e)
}
e.ArrEnd()
}
}
{
if len(s.Links) != 0 {
e.FieldStart("_links")
e.Raw(s.Links)
}
}
}
var jsonFieldsNameOfPageListResult = [2]string{
0: "results",
1: "_links",
}
// Decode decodes PageListResult from json.
func (s *PageListResult) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode PageListResult to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "results":
if err := func() error {
s.Results = make([]Page, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem Page
if err := elem.Decode(d); err != nil {
return err
}
s.Results = append(s.Results, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"results\"")
}
case "_links":
if err := func() error {
v, err := d.RawAppend(nil)
s.Links = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"_links\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode PageListResult")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *PageListResult) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PageListResult) 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.Results != nil {
e.FieldStart("results")
e.ArrStart()
for _, elem := range s.Results {
if len(elem) != 0 {
e.Raw(elem)
}
}
e.ArrEnd()
}
}
{
if s.Start.Set {
e.FieldStart("start")
s.Start.Encode(e)
}
}
{
if s.Limit.Set {
e.FieldStart("limit")
s.Limit.Encode(e)
}
}
{
if s.Size.Set {
e.FieldStart("size")
s.Size.Encode(e)
}
}
{
if s.TotalSize.Set {
e.FieldStart("totalSize")
s.TotalSize.Encode(e)
}
}
{
if len(s.Links) != 0 {
e.FieldStart("_links")
e.Raw(s.Links)
}
}
}
var jsonFieldsNameOfSearchResult = [6]string{
0: "results",
1: "start",
2: "limit",
3: "size",
4: "totalSize",
5: "_links",
}
// 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 "results":
if err := func() error {
s.Results = 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.Results = append(s.Results, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"results\"")
}
case "start":
if err := func() error {
s.Start.Reset()
if err := s.Start.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"start\"")
}
case "limit":
if err := func() error {
s.Limit.Reset()
if err := s.Limit.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"limit\"")
}
case "size":
if err := func() error {
s.Size.Reset()
if err := s.Size.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"size\"")
}
case "totalSize":
if err := func() error {
s.TotalSize.Reset()
if err := s.TotalSize.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"totalSize\"")
}
case "_links":
if err := func() error {
v, err := d.RawAppend(nil)
s.Links = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"_links\"")
}
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 *Space) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *Space) 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.Type.Set {
e.FieldStart("type")
s.Type.Encode(e)
}
}
{
if s.Status.Set {
e.FieldStart("status")
s.Status.Encode(e)
}
}
{
if len(s.Description) != 0 {
e.FieldStart("description")
e.Raw(s.Description)
}
}
{
if s.HomepageId.Set {
e.FieldStart("homepageId")
s.HomepageId.Encode(e)
}
}
{
if len(s.Icon) != 0 {
e.FieldStart("icon")
e.Raw(s.Icon)
}
}
}
var jsonFieldsNameOfSpace = [8]string{
0: "id",
1: "key",
2: "name",
3: "type",
4: "status",
5: "description",
6: "homepageId",
7: "icon",
}
// Decode decodes Space from json.
func (s *Space) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode Space 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 "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 "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 "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 "homepageId":
if err := func() error {
s.HomepageId.Reset()
if err := s.HomepageId.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"homepageId\"")
}
case "icon":
if err := func() error {
v, err := d.RawAppend(nil)
s.Icon = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"icon\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode Space")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *Space) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Space) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *SpaceListResult) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *SpaceListResult) encodeFields(e *jx.Encoder) {
{
if s.Results != nil {
e.FieldStart("results")
e.ArrStart()
for _, elem := range s.Results {
elem.Encode(e)
}
e.ArrEnd()
}
}
{
if len(s.Links) != 0 {
e.FieldStart("_links")
e.Raw(s.Links)
}
}
}
var jsonFieldsNameOfSpaceListResult = [2]string{
0: "results",
1: "_links",
}
// Decode decodes SpaceListResult from json.
func (s *SpaceListResult) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode SpaceListResult to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "results":
if err := func() error {
s.Results = make([]Space, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem Space
if err := elem.Decode(d); err != nil {
return err
}
s.Results = append(s.Results, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"results\"")
}
case "_links":
if err := func() error {
v, err := d.RawAppend(nil)
s.Links = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"_links\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode SpaceListResult")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *SpaceListResult) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SpaceListResult) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *SpaceV1) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *SpaceV1) 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.Type.Set {
e.FieldStart("type")
s.Type.Encode(e)
}
}
{
if s.Status.Set {
e.FieldStart("status")
s.Status.Encode(e)
}
}
{
if len(s.Description) != 0 {
e.FieldStart("description")
e.Raw(s.Description)
}
}
{
if len(s.Homepage) != 0 {
e.FieldStart("homepage")
e.Raw(s.Homepage)
}
}
{
if len(s.Links) != 0 {
e.FieldStart("_links")
e.Raw(s.Links)
}
}
}
var jsonFieldsNameOfSpaceV1 = [8]string{
0: "id",
1: "key",
2: "name",
3: "type",
4: "status",
5: "description",
6: "homepage",
7: "_links",
}
// Decode decodes SpaceV1 from json.
func (s *SpaceV1) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode SpaceV1 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 "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 "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 "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 "homepage":
if err := func() error {
v, err := d.RawAppend(nil)
s.Homepage = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"homepage\"")
}
case "_links":
if err := func() error {
v, err := d.RawAppend(nil)
s.Links = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"_links\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode SpaceV1")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *SpaceV1) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SpaceV1) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *UpdatePageRequest) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *UpdatePageRequest) encodeFields(e *jx.Encoder) {
{
e.FieldStart("id")
e.Str(s.ID)
}
{
e.FieldStart("title")
e.Str(s.Title)
}
{
e.FieldStart("status")
e.Str(s.Status)
}
{
e.FieldStart("body")
s.Body.Encode(e)
}
{
e.FieldStart("version")
s.Version.Encode(e)
}
}
var jsonFieldsNameOfUpdatePageRequest = [5]string{
0: "id",
1: "title",
2: "status",
3: "body",
4: "version",
}
// Decode decodes UpdatePageRequest from json.
func (s *UpdatePageRequest) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode UpdatePageRequest 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\"")
}
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 "status":
requiredBitSet[0] |= 1 << 2
if err := func() error {
v, err := d.Str()
s.Status = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"status\"")
}
case "body":
requiredBitSet[0] |= 1 << 3
if err := func() error {
if err := s.Body.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"body\"")
}
case "version":
requiredBitSet[0] |= 1 << 4
if err := func() error {
if err := s.Version.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"version\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode UpdatePageRequest")
}
// Validate required fields.
var failures []validate.FieldError
for i, mask := range [1]uint8{
0b00011111,
} {
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(jsonFieldsNameOfUpdatePageRequest) {
name = jsonFieldsNameOfUpdatePageRequest[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 *UpdatePageRequest) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UpdatePageRequest) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *VersionInput) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *VersionInput) encodeFields(e *jx.Encoder) {
{
if s.Number.Set {
e.FieldStart("number")
s.Number.Encode(e)
}
}
}
var jsonFieldsNameOfVersionInput = [1]string{
0: "number",
}
// Decode decodes VersionInput from json.
func (s *VersionInput) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode VersionInput to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "number":
if err := func() error {
s.Number.Reset()
if err := s.Number.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"number\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode VersionInput")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *VersionInput) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *VersionInput) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
