// 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 *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.Parent) != 0 {
e.FieldStart("parent")
e.Raw(s.Parent)
}
}
{
e.FieldStart("rich_text")
e.ArrStart()
for _, elem := range s.RichText {
if len(elem) != 0 {
e.Raw(elem)
}
}
e.ArrEnd()
}
}
var jsonFieldsNameOfAddCommentRequest = [2]string{
0: "parent",
1: "rich_text",
}
// 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 "parent":
requiredBitSet[0] |= 1 << 0
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\"")
}
case "rich_text":
requiredBitSet[0] |= 1 << 1
if err := func() error {
s.RichText = 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.RichText = append(s.RichText, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"rich_text\"")
}
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{
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(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 *AppendBlockChildrenRequest) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *AppendBlockChildrenRequest) encodeFields(e *jx.Encoder) {
{
e.FieldStart("children")
e.ArrStart()
for _, elem := range s.Children {
if len(elem) != 0 {
e.Raw(elem)
}
}
e.ArrEnd()
}
}
var jsonFieldsNameOfAppendBlockChildrenRequest = [1]string{
0: "children",
}
// Decode decodes AppendBlockChildrenRequest from json.
func (s *AppendBlockChildrenRequest) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode AppendBlockChildrenRequest to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "children":
requiredBitSet[0] |= 1 << 0
if err := func() error {
s.Children = 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.Children = append(s.Children, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"children\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode AppendBlockChildrenRequest")
}
// 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(jsonFieldsNameOfAppendBlockChildrenRequest) {
name = jsonFieldsNameOfAppendBlockChildrenRequest[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 *AppendBlockChildrenRequest) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AppendBlockChildrenRequest) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *Block) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *Block) encodeFields(e *jx.Encoder) {
{
if s.Object.Set {
e.FieldStart("object")
s.Object.Encode(e)
}
}
{
if s.ID.Set {
e.FieldStart("id")
s.ID.Encode(e)
}
}
{
if s.Type.Set {
e.FieldStart("type")
s.Type.Encode(e)
}
}
{
if s.Archived.Set {
e.FieldStart("archived")
s.Archived.Encode(e)
}
}
{
if s.HasChildren.Set {
e.FieldStart("has_children")
s.HasChildren.Encode(e)
}
}
{
if len(s.Parent) != 0 {
e.FieldStart("parent")
e.Raw(s.Parent)
}
}
}
var jsonFieldsNameOfBlock = [6]string{
0: "object",
1: "id",
2: "type",
3: "archived",
4: "has_children",
5: "parent",
}
// Decode decodes Block from json.
func (s *Block) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode Block to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "object":
if err := func() error {
s.Object.Reset()
if err := s.Object.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"object\"")
}
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 "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 "archived":
if err := func() error {
s.Archived.Reset()
if err := s.Archived.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"archived\"")
}
case "has_children":
if err := func() error {
s.HasChildren.Reset()
if err := s.HasChildren.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"has_children\"")
}
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 Block")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *Block) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Block) 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.Object.Set {
e.FieldStart("object")
s.Object.Encode(e)
}
}
{
if s.ID.Set {
e.FieldStart("id")
s.ID.Encode(e)
}
}
{
if len(s.Parent) != 0 {
e.FieldStart("parent")
e.Raw(s.Parent)
}
}
{
if s.DiscussionID.Set {
e.FieldStart("discussion_id")
s.DiscussionID.Encode(e)
}
}
{
if s.RichText != nil {
e.FieldStart("rich_text")
e.ArrStart()
for _, elem := range s.RichText {
if len(elem) != 0 {
e.Raw(elem)
}
}
e.ArrEnd()
}
}
{
if s.CreatedTime.Set {
e.FieldStart("created_time")
s.CreatedTime.Encode(e)
}
}
{
if len(s.CreatedBy) != 0 {
e.FieldStart("created_by")
e.Raw(s.CreatedBy)
}
}
}
var jsonFieldsNameOfComment = [7]string{
0: "object",
1: "id",
2: "parent",
3: "discussion_id",
4: "rich_text",
5: "created_time",
6: "created_by",
}
// 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 "object":
if err := func() error {
s.Object.Reset()
if err := s.Object.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"object\"")
}
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 "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\"")
}
case "discussion_id":
if err := func() error {
s.DiscussionID.Reset()
if err := s.DiscussionID.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"discussion_id\"")
}
case "rich_text":
if err := func() error {
s.RichText = 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.RichText = append(s.RichText, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"rich_text\"")
}
case "created_time":
if err := func() error {
s.CreatedTime.Reset()
if err := s.CreatedTime.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"created_time\"")
}
case "created_by":
if err := func() error {
v, err := d.RawAppend(nil)
s.CreatedBy = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"created_by\"")
}
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 *CreatePageRequest) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *CreatePageRequest) encodeFields(e *jx.Encoder) {
{
if len(s.Parent) != 0 {
e.FieldStart("parent")
e.Raw(s.Parent)
}
}
{
if len(s.Properties) != 0 {
e.FieldStart("properties")
e.Raw(s.Properties)
}
}
}
var jsonFieldsNameOfCreatePageRequest = [2]string{
0: "parent",
1: "properties",
}
// 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 "parent":
requiredBitSet[0] |= 1 << 0
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\"")
}
case "properties":
requiredBitSet[0] |= 1 << 1
if err := func() error {
v, err := d.RawAppend(nil)
s.Properties = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"properties\"")
}
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{
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(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 *Database) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *Database) encodeFields(e *jx.Encoder) {
{
if s.Object.Set {
e.FieldStart("object")
s.Object.Encode(e)
}
}
{
if s.ID.Set {
e.FieldStart("id")
s.ID.Encode(e)
}
}
{
if s.Title != nil {
e.FieldStart("title")
e.ArrStart()
for _, elem := range s.Title {
if len(elem) != 0 {
e.Raw(elem)
}
}
e.ArrEnd()
}
}
{
if s.Description != nil {
e.FieldStart("description")
e.ArrStart()
for _, elem := range s.Description {
if len(elem) != 0 {
e.Raw(elem)
}
}
e.ArrEnd()
}
}
{
if len(s.Properties) != 0 {
e.FieldStart("properties")
e.Raw(s.Properties)
}
}
{
if len(s.Parent) != 0 {
e.FieldStart("parent")
e.Raw(s.Parent)
}
}
{
if s.URL.Set {
e.FieldStart("url")
s.URL.Encode(e)
}
}
{
if s.Archived.Set {
e.FieldStart("archived")
s.Archived.Encode(e)
}
}
}
var jsonFieldsNameOfDatabase = [8]string{
0: "object",
1: "id",
2: "title",
3: "description",
4: "properties",
5: "parent",
6: "url",
7: "archived",
}
// Decode decodes Database from json.
func (s *Database) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode Database to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "object":
if err := func() error {
s.Object.Reset()
if err := s.Object.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"object\"")
}
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 = 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.Title = append(s.Title, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"title\"")
}
case "description":
if err := func() error {
s.Description = 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.Description = append(s.Description, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"description\"")
}
case "properties":
if err := func() error {
v, err := d.RawAppend(nil)
s.Properties = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"properties\"")
}
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\"")
}
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 "archived":
if err := func() error {
s.Archived.Reset()
if err := s.Archived.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"archived\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode Database")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *Database) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Database) 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 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.Object.Set {
e.FieldStart("object")
s.Object.Encode(e)
}
}
{
if s.ID.Set {
e.FieldStart("id")
s.ID.Encode(e)
}
}
{
if s.CreatedTime.Set {
e.FieldStart("created_time")
s.CreatedTime.Encode(e)
}
}
{
if s.LastEditedTime.Set {
e.FieldStart("last_edited_time")
s.LastEditedTime.Encode(e)
}
}
{
if s.Archived.Set {
e.FieldStart("archived")
s.Archived.Encode(e)
}
}
{
if s.URL.Set {
e.FieldStart("url")
s.URL.Encode(e)
}
}
{
if len(s.Parent) != 0 {
e.FieldStart("parent")
e.Raw(s.Parent)
}
}
{
if len(s.Properties) != 0 {
e.FieldStart("properties")
e.Raw(s.Properties)
}
}
{
if len(s.Icon) != 0 {
e.FieldStart("icon")
e.Raw(s.Icon)
}
}
{
if len(s.Cover) != 0 {
e.FieldStart("cover")
e.Raw(s.Cover)
}
}
}
var jsonFieldsNameOfPage = [10]string{
0: "object",
1: "id",
2: "created_time",
3: "last_edited_time",
4: "archived",
5: "url",
6: "parent",
7: "properties",
8: "icon",
9: "cover",
}
// 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 "object":
if err := func() error {
s.Object.Reset()
if err := s.Object.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"object\"")
}
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 "created_time":
if err := func() error {
s.CreatedTime.Reset()
if err := s.CreatedTime.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"created_time\"")
}
case "last_edited_time":
if err := func() error {
s.LastEditedTime.Reset()
if err := s.LastEditedTime.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"last_edited_time\"")
}
case "archived":
if err := func() error {
s.Archived.Reset()
if err := s.Archived.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"archived\"")
}
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 "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\"")
}
case "properties":
if err := func() error {
v, err := d.RawAppend(nil)
s.Properties = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"properties\"")
}
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\"")
}
case "cover":
if err := func() error {
v, err := d.RawAppend(nil)
s.Cover = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"cover\"")
}
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 *PaginatedList) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *PaginatedList) encodeFields(e *jx.Encoder) {
{
if s.Object.Set {
e.FieldStart("object")
s.Object.Encode(e)
}
}
{
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.HasMore.Set {
e.FieldStart("has_more")
s.HasMore.Encode(e)
}
}
{
if s.NextCursor.Set {
e.FieldStart("next_cursor")
s.NextCursor.Encode(e)
}
}
{
if s.Type.Set {
e.FieldStart("type")
s.Type.Encode(e)
}
}
}
var jsonFieldsNameOfPaginatedList = [5]string{
0: "object",
1: "results",
2: "has_more",
3: "next_cursor",
4: "type",
}
// Decode decodes PaginatedList from json.
func (s *PaginatedList) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode PaginatedList to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "object":
if err := func() error {
s.Object.Reset()
if err := s.Object.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"object\"")
}
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 "has_more":
if err := func() error {
s.HasMore.Reset()
if err := s.HasMore.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"has_more\"")
}
case "next_cursor":
if err := func() error {
s.NextCursor.Reset()
if err := s.NextCursor.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"next_cursor\"")
}
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\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode PaginatedList")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *PaginatedList) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaginatedList) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *QueryDatabaseRequest) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *QueryDatabaseRequest) encodeFields(e *jx.Encoder) {
{
if len(s.Filter) != 0 {
e.FieldStart("filter")
e.Raw(s.Filter)
}
}
{
if len(s.Sorts) != 0 {
e.FieldStart("sorts")
e.Raw(s.Sorts)
}
}
{
if s.PageSize.Set {
e.FieldStart("page_size")
s.PageSize.Encode(e)
}
}
}
var jsonFieldsNameOfQueryDatabaseRequest = [3]string{
0: "filter",
1: "sorts",
2: "page_size",
}
// Decode decodes QueryDatabaseRequest from json.
func (s *QueryDatabaseRequest) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode QueryDatabaseRequest to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "filter":
if err := func() error {
v, err := d.RawAppend(nil)
s.Filter = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"filter\"")
}
case "sorts":
if err := func() error {
v, err := d.RawAppend(nil)
s.Sorts = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"sorts\"")
}
case "page_size":
if err := func() error {
s.PageSize.Reset()
if err := s.PageSize.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"page_size\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode QueryDatabaseRequest")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *QueryDatabaseRequest) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *QueryDatabaseRequest) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *SearchRequest) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *SearchRequest) encodeFields(e *jx.Encoder) {
{
if s.Query.Set {
e.FieldStart("query")
s.Query.Encode(e)
}
}
{
if len(s.Filter) != 0 {
e.FieldStart("filter")
e.Raw(s.Filter)
}
}
{
if len(s.Sort) != 0 {
e.FieldStart("sort")
e.Raw(s.Sort)
}
}
{
if s.PageSize.Set {
e.FieldStart("page_size")
s.PageSize.Encode(e)
}
}
}
var jsonFieldsNameOfSearchRequest = [4]string{
0: "query",
1: "filter",
2: "sort",
3: "page_size",
}
// Decode decodes SearchRequest from json.
func (s *SearchRequest) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode SearchRequest to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "query":
if err := func() error {
s.Query.Reset()
if err := s.Query.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"query\"")
}
case "filter":
if err := func() error {
v, err := d.RawAppend(nil)
s.Filter = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"filter\"")
}
case "sort":
if err := func() error {
v, err := d.RawAppend(nil)
s.Sort = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"sort\"")
}
case "page_size":
if err := func() error {
s.PageSize.Reset()
if err := s.PageSize.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"page_size\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode SearchRequest")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *SearchRequest) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SearchRequest) 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) {
{
if len(s.Properties) != 0 {
e.FieldStart("properties")
e.Raw(s.Properties)
}
}
}
var jsonFieldsNameOfUpdatePageRequest = [1]string{
0: "properties",
}
// 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 "properties":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.RawAppend(nil)
s.Properties = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"properties\"")
}
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{
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(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 *User) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *User) encodeFields(e *jx.Encoder) {
{
if s.Object.Set {
e.FieldStart("object")
s.Object.Encode(e)
}
}
{
if s.ID.Set {
e.FieldStart("id")
s.ID.Encode(e)
}
}
{
if s.Type.Set {
e.FieldStart("type")
s.Type.Encode(e)
}
}
{
if s.Name.Set {
e.FieldStart("name")
s.Name.Encode(e)
}
}
{
if s.AvatarURL.Set {
e.FieldStart("avatar_url")
s.AvatarURL.Encode(e)
}
}
{
if len(s.Person) != 0 {
e.FieldStart("person")
e.Raw(s.Person)
}
}
{
if len(s.Bot) != 0 {
e.FieldStart("bot")
e.Raw(s.Bot)
}
}
}
var jsonFieldsNameOfUser = [7]string{
0: "object",
1: "id",
2: "type",
3: "name",
4: "avatar_url",
5: "person",
6: "bot",
}
// 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 "object":
if err := func() error {
s.Object.Reset()
if err := s.Object.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"object\"")
}
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 "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 "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 "avatar_url":
if err := func() error {
s.AvatarURL.Reset()
if err := s.AvatarURL.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"avatar_url\"")
}
case "person":
if err := func() error {
v, err := d.RawAppend(nil)
s.Person = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"person\"")
}
case "bot":
if err := func() error {
v, err := d.RawAppend(nil)
s.Bot = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"bot\"")
}
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)
}
