// 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 *AddTaskToSectionRequest) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *AddTaskToSectionRequest) encodeFields(e *jx.Encoder) {
{
e.FieldStart("data")
s.Data.Encode(e)
}
}
var jsonFieldsNameOfAddTaskToSectionRequest = [1]string{
0: "data",
}
// Decode decodes AddTaskToSectionRequest from json.
func (s *AddTaskToSectionRequest) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode AddTaskToSectionRequest to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "data":
requiredBitSet[0] |= 1 << 0
if err := func() error {
if err := s.Data.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"data\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode AddTaskToSectionRequest")
}
// 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(jsonFieldsNameOfAddTaskToSectionRequest) {
name = jsonFieldsNameOfAddTaskToSectionRequest[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 *AddTaskToSectionRequest) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AddTaskToSectionRequest) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *AddTaskToSectionRequestData) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *AddTaskToSectionRequestData) encodeFields(e *jx.Encoder) {
{
if s.Task.Set {
e.FieldStart("task")
s.Task.Encode(e)
}
}
}
var jsonFieldsNameOfAddTaskToSectionRequestData = [1]string{
0: "task",
}
// Decode decodes AddTaskToSectionRequestData from json.
func (s *AddTaskToSectionRequestData) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode AddTaskToSectionRequestData to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "task":
if err := func() error {
s.Task.Reset()
if err := s.Task.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"task\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode AddTaskToSectionRequestData")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *AddTaskToSectionRequestData) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AddTaskToSectionRequestData) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *CreateProjectRequest) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *CreateProjectRequest) encodeFields(e *jx.Encoder) {
{
e.FieldStart("data")
s.Data.Encode(e)
}
}
var jsonFieldsNameOfCreateProjectRequest = [1]string{
0: "data",
}
// Decode decodes CreateProjectRequest from json.
func (s *CreateProjectRequest) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode CreateProjectRequest to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "data":
requiredBitSet[0] |= 1 << 0
if err := func() error {
if err := s.Data.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"data\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode CreateProjectRequest")
}
// 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(jsonFieldsNameOfCreateProjectRequest) {
name = jsonFieldsNameOfCreateProjectRequest[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 *CreateProjectRequest) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CreateProjectRequest) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *CreateProjectRequestData) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *CreateProjectRequestData) encodeFields(e *jx.Encoder) {
{
if s.Name.Set {
e.FieldStart("name")
s.Name.Encode(e)
}
}
{
if s.Workspace.Set {
e.FieldStart("workspace")
s.Workspace.Encode(e)
}
}
{
if s.Team.Set {
e.FieldStart("team")
s.Team.Encode(e)
}
}
{
if s.Notes.Set {
e.FieldStart("notes")
s.Notes.Encode(e)
}
}
{
if s.Color.Set {
e.FieldStart("color")
s.Color.Encode(e)
}
}
{
if s.DefaultView.Set {
e.FieldStart("default_view")
s.DefaultView.Encode(e)
}
}
{
if s.DueOn.Set {
e.FieldStart("due_on")
s.DueOn.Encode(e)
}
}
}
var jsonFieldsNameOfCreateProjectRequestData = [7]string{
0: "name",
1: "workspace",
2: "team",
3: "notes",
4: "color",
5: "default_view",
6: "due_on",
}
// Decode decodes CreateProjectRequestData from json.
func (s *CreateProjectRequestData) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode CreateProjectRequestData to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "name":
if err := func() error {
s.Name.Reset()
if err := s.Name.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"name\"")
}
case "workspace":
if err := func() error {
s.Workspace.Reset()
if err := s.Workspace.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"workspace\"")
}
case "team":
if err := func() error {
s.Team.Reset()
if err := s.Team.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"team\"")
}
case "notes":
if err := func() error {
s.Notes.Reset()
if err := s.Notes.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"notes\"")
}
case "color":
if err := func() error {
s.Color.Reset()
if err := s.Color.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"color\"")
}
case "default_view":
if err := func() error {
s.DefaultView.Reset()
if err := s.DefaultView.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"default_view\"")
}
case "due_on":
if err := func() error {
s.DueOn.Reset()
if err := s.DueOn.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"due_on\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode CreateProjectRequestData")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *CreateProjectRequestData) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CreateProjectRequestData) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *CreateSectionRequest) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *CreateSectionRequest) encodeFields(e *jx.Encoder) {
{
e.FieldStart("data")
s.Data.Encode(e)
}
}
var jsonFieldsNameOfCreateSectionRequest = [1]string{
0: "data",
}
// Decode decodes CreateSectionRequest from json.
func (s *CreateSectionRequest) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode CreateSectionRequest to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "data":
requiredBitSet[0] |= 1 << 0
if err := func() error {
if err := s.Data.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"data\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode CreateSectionRequest")
}
// 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(jsonFieldsNameOfCreateSectionRequest) {
name = jsonFieldsNameOfCreateSectionRequest[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 *CreateSectionRequest) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CreateSectionRequest) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *CreateSectionRequestData) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *CreateSectionRequestData) encodeFields(e *jx.Encoder) {
{
if s.Name.Set {
e.FieldStart("name")
s.Name.Encode(e)
}
}
}
var jsonFieldsNameOfCreateSectionRequestData = [1]string{
0: "name",
}
// Decode decodes CreateSectionRequestData from json.
func (s *CreateSectionRequestData) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode CreateSectionRequestData to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "name":
if err := func() error {
s.Name.Reset()
if err := s.Name.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"name\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode CreateSectionRequestData")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *CreateSectionRequestData) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CreateSectionRequestData) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *CreateStoryRequest) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *CreateStoryRequest) encodeFields(e *jx.Encoder) {
{
e.FieldStart("data")
s.Data.Encode(e)
}
}
var jsonFieldsNameOfCreateStoryRequest = [1]string{
0: "data",
}
// Decode decodes CreateStoryRequest from json.
func (s *CreateStoryRequest) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode CreateStoryRequest to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "data":
requiredBitSet[0] |= 1 << 0
if err := func() error {
if err := s.Data.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"data\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode CreateStoryRequest")
}
// 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(jsonFieldsNameOfCreateStoryRequest) {
name = jsonFieldsNameOfCreateStoryRequest[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 *CreateStoryRequest) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CreateStoryRequest) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *CreateStoryRequestData) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *CreateStoryRequestData) encodeFields(e *jx.Encoder) {
{
if s.Text.Set {
e.FieldStart("text")
s.Text.Encode(e)
}
}
}
var jsonFieldsNameOfCreateStoryRequestData = [1]string{
0: "text",
}
// Decode decodes CreateStoryRequestData from json.
func (s *CreateStoryRequestData) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode CreateStoryRequestData to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "text":
if err := func() error {
s.Text.Reset()
if err := s.Text.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"text\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode CreateStoryRequestData")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *CreateStoryRequestData) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CreateStoryRequestData) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *CreateSubtaskRequest) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *CreateSubtaskRequest) encodeFields(e *jx.Encoder) {
{
e.FieldStart("data")
s.Data.Encode(e)
}
}
var jsonFieldsNameOfCreateSubtaskRequest = [1]string{
0: "data",
}
// Decode decodes CreateSubtaskRequest from json.
func (s *CreateSubtaskRequest) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode CreateSubtaskRequest to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "data":
requiredBitSet[0] |= 1 << 0
if err := func() error {
if err := s.Data.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"data\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode CreateSubtaskRequest")
}
// 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(jsonFieldsNameOfCreateSubtaskRequest) {
name = jsonFieldsNameOfCreateSubtaskRequest[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 *CreateSubtaskRequest) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CreateSubtaskRequest) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *CreateSubtaskRequestData) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *CreateSubtaskRequestData) encodeFields(e *jx.Encoder) {
{
if s.Name.Set {
e.FieldStart("name")
s.Name.Encode(e)
}
}
{
if s.Notes.Set {
e.FieldStart("notes")
s.Notes.Encode(e)
}
}
{
if s.DueOn.Set {
e.FieldStart("due_on")
s.DueOn.Encode(e)
}
}
{
if s.Assignee.Set {
e.FieldStart("assignee")
s.Assignee.Encode(e)
}
}
}
var jsonFieldsNameOfCreateSubtaskRequestData = [4]string{
0: "name",
1: "notes",
2: "due_on",
3: "assignee",
}
// Decode decodes CreateSubtaskRequestData from json.
func (s *CreateSubtaskRequestData) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode CreateSubtaskRequestData to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "name":
if err := func() error {
s.Name.Reset()
if err := s.Name.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"name\"")
}
case "notes":
if err := func() error {
s.Notes.Reset()
if err := s.Notes.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"notes\"")
}
case "due_on":
if err := func() error {
s.DueOn.Reset()
if err := s.DueOn.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"due_on\"")
}
case "assignee":
if err := func() error {
s.Assignee.Reset()
if err := s.Assignee.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"assignee\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode CreateSubtaskRequestData")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *CreateSubtaskRequestData) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CreateSubtaskRequestData) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *CreateTagRequest) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *CreateTagRequest) encodeFields(e *jx.Encoder) {
{
e.FieldStart("data")
s.Data.Encode(e)
}
}
var jsonFieldsNameOfCreateTagRequest = [1]string{
0: "data",
}
// Decode decodes CreateTagRequest from json.
func (s *CreateTagRequest) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode CreateTagRequest to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "data":
requiredBitSet[0] |= 1 << 0
if err := func() error {
if err := s.Data.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"data\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode CreateTagRequest")
}
// 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(jsonFieldsNameOfCreateTagRequest) {
name = jsonFieldsNameOfCreateTagRequest[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 *CreateTagRequest) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CreateTagRequest) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *CreateTagRequestData) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *CreateTagRequestData) encodeFields(e *jx.Encoder) {
{
if s.Name.Set {
e.FieldStart("name")
s.Name.Encode(e)
}
}
{
if s.Workspace.Set {
e.FieldStart("workspace")
s.Workspace.Encode(e)
}
}
{
if s.Color.Set {
e.FieldStart("color")
s.Color.Encode(e)
}
}
}
var jsonFieldsNameOfCreateTagRequestData = [3]string{
0: "name",
1: "workspace",
2: "color",
}
// Decode decodes CreateTagRequestData from json.
func (s *CreateTagRequestData) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode CreateTagRequestData to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "name":
if err := func() error {
s.Name.Reset()
if err := s.Name.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"name\"")
}
case "workspace":
if err := func() error {
s.Workspace.Reset()
if err := s.Workspace.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"workspace\"")
}
case "color":
if err := func() error {
s.Color.Reset()
if err := s.Color.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"color\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode CreateTagRequestData")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *CreateTagRequestData) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CreateTagRequestData) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *CreateTaskRequest) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *CreateTaskRequest) encodeFields(e *jx.Encoder) {
{
e.FieldStart("data")
s.Data.Encode(e)
}
}
var jsonFieldsNameOfCreateTaskRequest = [1]string{
0: "data",
}
// Decode decodes CreateTaskRequest from json.
func (s *CreateTaskRequest) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode CreateTaskRequest to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "data":
requiredBitSet[0] |= 1 << 0
if err := func() error {
if err := s.Data.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"data\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode CreateTaskRequest")
}
// 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(jsonFieldsNameOfCreateTaskRequest) {
name = jsonFieldsNameOfCreateTaskRequest[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 *CreateTaskRequest) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CreateTaskRequest) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *CreateTaskRequestData) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *CreateTaskRequestData) encodeFields(e *jx.Encoder) {
{
if s.Name.Set {
e.FieldStart("name")
s.Name.Encode(e)
}
}
{
if s.Workspace.Set {
e.FieldStart("workspace")
s.Workspace.Encode(e)
}
}
{
if s.Projects != nil {
e.FieldStart("projects")
e.ArrStart()
for _, elem := range s.Projects {
e.Str(elem)
}
e.ArrEnd()
}
}
{
if s.Notes.Set {
e.FieldStart("notes")
s.Notes.Encode(e)
}
}
{
if s.HTMLNotes.Set {
e.FieldStart("html_notes")
s.HTMLNotes.Encode(e)
}
}
{
if s.DueOn.Set {
e.FieldStart("due_on")
s.DueOn.Encode(e)
}
}
{
if s.DueAt.Set {
e.FieldStart("due_at")
s.DueAt.Encode(e)
}
}
{
if s.StartOn.Set {
e.FieldStart("start_on")
s.StartOn.Encode(e)
}
}
{
if s.Assignee.Set {
e.FieldStart("assignee")
s.Assignee.Encode(e)
}
}
{
if s.Parent.Set {
e.FieldStart("parent")
s.Parent.Encode(e)
}
}
{
if s.Tags != nil {
e.FieldStart("tags")
e.ArrStart()
for _, elem := range s.Tags {
e.Str(elem)
}
e.ArrEnd()
}
}
}
var jsonFieldsNameOfCreateTaskRequestData = [11]string{
0: "name",
1: "workspace",
2: "projects",
3: "notes",
4: "html_notes",
5: "due_on",
6: "due_at",
7: "start_on",
8: "assignee",
9: "parent",
10: "tags",
}
// Decode decodes CreateTaskRequestData from json.
func (s *CreateTaskRequestData) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode CreateTaskRequestData to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "name":
if err := func() error {
s.Name.Reset()
if err := s.Name.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"name\"")
}
case "workspace":
if err := func() error {
s.Workspace.Reset()
if err := s.Workspace.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"workspace\"")
}
case "projects":
if err := func() error {
s.Projects = 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.Projects = append(s.Projects, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"projects\"")
}
case "notes":
if err := func() error {
s.Notes.Reset()
if err := s.Notes.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"notes\"")
}
case "html_notes":
if err := func() error {
s.HTMLNotes.Reset()
if err := s.HTMLNotes.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"html_notes\"")
}
case "due_on":
if err := func() error {
s.DueOn.Reset()
if err := s.DueOn.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"due_on\"")
}
case "due_at":
if err := func() error {
s.DueAt.Reset()
if err := s.DueAt.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"due_at\"")
}
case "start_on":
if err := func() error {
s.StartOn.Reset()
if err := s.StartOn.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"start_on\"")
}
case "assignee":
if err := func() error {
s.Assignee.Reset()
if err := s.Assignee.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"assignee\"")
}
case "parent":
if err := func() error {
s.Parent.Reset()
if err := s.Parent.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"parent\"")
}
case "tags":
if err := func() error {
s.Tags = make([]string, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem string
v, err := d.Str()
elem = string(v)
if err != nil {
return err
}
s.Tags = append(s.Tags, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"tags\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode CreateTaskRequestData")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *CreateTaskRequestData) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CreateTaskRequestData) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *EmptyDataResponse) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *EmptyDataResponse) encodeFields(e *jx.Encoder) {
{
if len(s.Data) != 0 {
e.FieldStart("data")
e.Raw(s.Data)
}
}
}
var jsonFieldsNameOfEmptyDataResponse = [1]string{
0: "data",
}
// Decode decodes EmptyDataResponse from json.
func (s *EmptyDataResponse) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode EmptyDataResponse to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "data":
if err := func() error {
v, err := d.RawAppend(nil)
s.Data = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"data\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode EmptyDataResponse")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *EmptyDataResponse) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *EmptyDataResponse) 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 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 TaskAssignee as json.
func (o OptNilTaskAssignee) Encode(e *jx.Encoder) {
if !o.Set {
return
}
if o.Null {
e.Null()
return
}
o.Value.Encode(e)
}
// Decode decodes TaskAssignee from json.
func (o *OptNilTaskAssignee) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptNilTaskAssignee to nil")
}
if d.Next() == jx.Null {
if err := d.Null(); err != nil {
return err
}
var v TaskAssignee
o.Value = v
o.Set = true
o.Null = true
return nil
}
o.Set = true
o.Null = false
if err := o.Value.Decode(d); err != nil {
return err
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptNilTaskAssignee) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptNilTaskAssignee) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes TaskParent as json.
func (o OptNilTaskParent) Encode(e *jx.Encoder) {
if !o.Set {
return
}
if o.Null {
e.Null()
return
}
o.Value.Encode(e)
}
// Decode decodes TaskParent from json.
func (o *OptNilTaskParent) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptNilTaskParent to nil")
}
if d.Next() == jx.Null {
if err := d.Null(); err != nil {
return err
}
var v TaskParent
o.Value = v
o.Set = true
o.Null = true
return nil
}
o.Set = true
o.Null = false
if err := o.Value.Decode(d); err != nil {
return err
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptNilTaskParent) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptNilTaskParent) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes Project as json.
func (o OptProject) Encode(e *jx.Encoder) {
if !o.Set {
return
}
o.Value.Encode(e)
}
// Decode decodes Project from json.
func (o *OptProject) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptProject to nil")
}
o.Set = true
if err := o.Value.Decode(d); err != nil {
return err
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptProject) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptProject) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes ProjectTeam as json.
func (o OptProjectTeam) Encode(e *jx.Encoder) {
if !o.Set {
return
}
o.Value.Encode(e)
}
// Decode decodes ProjectTeam from json.
func (o *OptProjectTeam) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptProjectTeam to nil")
}
o.Set = true
if err := o.Value.Decode(d); err != nil {
return err
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptProjectTeam) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptProjectTeam) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes ProjectWorkspace as json.
func (o OptProjectWorkspace) Encode(e *jx.Encoder) {
if !o.Set {
return
}
o.Value.Encode(e)
}
// Decode decodes ProjectWorkspace from json.
func (o *OptProjectWorkspace) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptProjectWorkspace to nil")
}
o.Set = true
if err := o.Value.Decode(d); err != nil {
return err
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptProjectWorkspace) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptProjectWorkspace) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes Section as json.
func (o OptSection) Encode(e *jx.Encoder) {
if !o.Set {
return
}
o.Value.Encode(e)
}
// Decode decodes Section from json.
func (o *OptSection) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptSection to nil")
}
o.Set = true
if err := o.Value.Decode(d); err != nil {
return err
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptSection) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptSection) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes Story as json.
func (o OptStory) Encode(e *jx.Encoder) {
if !o.Set {
return
}
o.Value.Encode(e)
}
// Decode decodes Story from json.
func (o *OptStory) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptStory to nil")
}
o.Set = true
if err := o.Value.Decode(d); err != nil {
return err
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptStory) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptStory) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes StoryCreatedBy as json.
func (o OptStoryCreatedBy) Encode(e *jx.Encoder) {
if !o.Set {
return
}
o.Value.Encode(e)
}
// Decode decodes StoryCreatedBy from json.
func (o *OptStoryCreatedBy) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptStoryCreatedBy to nil")
}
o.Set = true
if err := o.Value.Decode(d); err != nil {
return err
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptStoryCreatedBy) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptStoryCreatedBy) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes string as json.
func (o OptString) Encode(e *jx.Encoder) {
if !o.Set {
return
}
e.Str(string(o.Value))
}
// Decode decodes string from json.
func (o *OptString) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptString to nil")
}
o.Set = true
v, err := d.Str()
if err != nil {
return err
}
o.Value = string(v)
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptString) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptString) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes Tag as json.
func (o OptTag) Encode(e *jx.Encoder) {
if !o.Set {
return
}
o.Value.Encode(e)
}
// Decode decodes Tag from json.
func (o *OptTag) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptTag to nil")
}
o.Set = true
if err := o.Value.Decode(d); err != nil {
return err
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptTag) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptTag) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes Task as json.
func (o OptTask) Encode(e *jx.Encoder) {
if !o.Set {
return
}
o.Value.Encode(e)
}
// Decode decodes Task from json.
func (o *OptTask) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptTask to nil")
}
o.Set = true
if err := o.Value.Decode(d); err != nil {
return err
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptTask) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptTask) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes User as json.
func (o OptUser) Encode(e *jx.Encoder) {
if !o.Set {
return
}
o.Value.Encode(e)
}
// Decode decodes User from json.
func (o *OptUser) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptUser to nil")
}
o.Set = true
if err := o.Value.Decode(d); err != nil {
return err
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptUser) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptUser) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes Workspace as json.
func (o OptWorkspace) Encode(e *jx.Encoder) {
if !o.Set {
return
}
o.Value.Encode(e)
}
// Decode decodes Workspace from json.
func (o *OptWorkspace) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptWorkspace to nil")
}
o.Set = true
if err := o.Value.Decode(d); err != nil {
return err
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptWorkspace) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptWorkspace) 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.Gid.Set {
e.FieldStart("gid")
s.Gid.Encode(e)
}
}
{
if s.Name.Set {
e.FieldStart("name")
s.Name.Encode(e)
}
}
{
if s.ResourceType.Set {
e.FieldStart("resource_type")
s.ResourceType.Encode(e)
}
}
{
if s.Archived.Set {
e.FieldStart("archived")
s.Archived.Encode(e)
}
}
{
if s.Color.Set {
e.FieldStart("color")
s.Color.Encode(e)
}
}
{
if s.Notes.Set {
e.FieldStart("notes")
s.Notes.Encode(e)
}
}
{
if s.DefaultView.Set {
e.FieldStart("default_view")
s.DefaultView.Encode(e)
}
}
{
if s.DueOn.Set {
e.FieldStart("due_on")
s.DueOn.Encode(e)
}
}
{
if s.CreatedAt.Set {
e.FieldStart("created_at")
s.CreatedAt.Encode(e)
}
}
{
if s.ModifiedAt.Set {
e.FieldStart("modified_at")
s.ModifiedAt.Encode(e)
}
}
{
if s.Workspace.Set {
e.FieldStart("workspace")
s.Workspace.Encode(e)
}
}
{
if s.Team.Set {
e.FieldStart("team")
s.Team.Encode(e)
}
}
}
var jsonFieldsNameOfProject = [12]string{
0: "gid",
1: "name",
2: "resource_type",
3: "archived",
4: "color",
5: "notes",
6: "default_view",
7: "due_on",
8: "created_at",
9: "modified_at",
10: "workspace",
11: "team",
}
// 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 "gid":
if err := func() error {
s.Gid.Reset()
if err := s.Gid.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"gid\"")
}
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 "resource_type":
if err := func() error {
s.ResourceType.Reset()
if err := s.ResourceType.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"resource_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 "color":
if err := func() error {
s.Color.Reset()
if err := s.Color.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"color\"")
}
case "notes":
if err := func() error {
s.Notes.Reset()
if err := s.Notes.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"notes\"")
}
case "default_view":
if err := func() error {
s.DefaultView.Reset()
if err := s.DefaultView.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"default_view\"")
}
case "due_on":
if err := func() error {
s.DueOn.Reset()
if err := s.DueOn.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"due_on\"")
}
case "created_at":
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 \"created_at\"")
}
case "modified_at":
if err := func() error {
s.ModifiedAt.Reset()
if err := s.ModifiedAt.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"modified_at\"")
}
case "workspace":
if err := func() error {
s.Workspace.Reset()
if err := s.Workspace.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"workspace\"")
}
case "team":
if err := func() error {
s.Team.Reset()
if err := s.Team.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"team\"")
}
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 *ProjectListResponse) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *ProjectListResponse) encodeFields(e *jx.Encoder) {
{
if s.Data != nil {
e.FieldStart("data")
e.ArrStart()
for _, elem := range s.Data {
elem.Encode(e)
}
e.ArrEnd()
}
}
}
var jsonFieldsNameOfProjectListResponse = [1]string{
0: "data",
}
// Decode decodes ProjectListResponse from json.
func (s *ProjectListResponse) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode ProjectListResponse to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "data":
if err := func() error {
s.Data = 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.Data = append(s.Data, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"data\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode ProjectListResponse")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *ProjectListResponse) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ProjectListResponse) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *ProjectResponse) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *ProjectResponse) encodeFields(e *jx.Encoder) {
{
if s.Data.Set {
e.FieldStart("data")
s.Data.Encode(e)
}
}
}
var jsonFieldsNameOfProjectResponse = [1]string{
0: "data",
}
// Decode decodes ProjectResponse from json.
func (s *ProjectResponse) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode ProjectResponse to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "data":
if err := func() error {
s.Data.Reset()
if err := s.Data.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"data\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode ProjectResponse")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *ProjectResponse) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ProjectResponse) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *ProjectTeam) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *ProjectTeam) encodeFields(e *jx.Encoder) {
{
if s.Gid.Set {
e.FieldStart("gid")
s.Gid.Encode(e)
}
}
{
if s.Name.Set {
e.FieldStart("name")
s.Name.Encode(e)
}
}
}
var jsonFieldsNameOfProjectTeam = [2]string{
0: "gid",
1: "name",
}
// Decode decodes ProjectTeam from json.
func (s *ProjectTeam) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode ProjectTeam to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "gid":
if err := func() error {
s.Gid.Reset()
if err := s.Gid.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"gid\"")
}
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\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode ProjectTeam")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *ProjectTeam) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ProjectTeam) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *ProjectWorkspace) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *ProjectWorkspace) encodeFields(e *jx.Encoder) {
{
if s.Gid.Set {
e.FieldStart("gid")
s.Gid.Encode(e)
}
}
{
if s.Name.Set {
e.FieldStart("name")
s.Name.Encode(e)
}
}
}
var jsonFieldsNameOfProjectWorkspace = [2]string{
0: "gid",
1: "name",
}
// Decode decodes ProjectWorkspace from json.
func (s *ProjectWorkspace) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode ProjectWorkspace to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "gid":
if err := func() error {
s.Gid.Reset()
if err := s.Gid.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"gid\"")
}
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\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode ProjectWorkspace")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *ProjectWorkspace) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ProjectWorkspace) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *Section) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *Section) encodeFields(e *jx.Encoder) {
{
if s.Gid.Set {
e.FieldStart("gid")
s.Gid.Encode(e)
}
}
{
if s.Name.Set {
e.FieldStart("name")
s.Name.Encode(e)
}
}
{
if s.ResourceType.Set {
e.FieldStart("resource_type")
s.ResourceType.Encode(e)
}
}
}
var jsonFieldsNameOfSection = [3]string{
0: "gid",
1: "name",
2: "resource_type",
}
// Decode decodes Section from json.
func (s *Section) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode Section to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "gid":
if err := func() error {
s.Gid.Reset()
if err := s.Gid.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"gid\"")
}
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 "resource_type":
if err := func() error {
s.ResourceType.Reset()
if err := s.ResourceType.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"resource_type\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode Section")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *Section) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Section) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *SectionListResponse) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *SectionListResponse) encodeFields(e *jx.Encoder) {
{
if s.Data != nil {
e.FieldStart("data")
e.ArrStart()
for _, elem := range s.Data {
elem.Encode(e)
}
e.ArrEnd()
}
}
}
var jsonFieldsNameOfSectionListResponse = [1]string{
0: "data",
}
// Decode decodes SectionListResponse from json.
func (s *SectionListResponse) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode SectionListResponse to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "data":
if err := func() error {
s.Data = make([]Section, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem Section
if err := elem.Decode(d); err != nil {
return err
}
s.Data = append(s.Data, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"data\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode SectionListResponse")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *SectionListResponse) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SectionListResponse) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *SectionResponse) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *SectionResponse) encodeFields(e *jx.Encoder) {
{
if s.Data.Set {
e.FieldStart("data")
s.Data.Encode(e)
}
}
}
var jsonFieldsNameOfSectionResponse = [1]string{
0: "data",
}
// Decode decodes SectionResponse from json.
func (s *SectionResponse) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode SectionResponse to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "data":
if err := func() error {
s.Data.Reset()
if err := s.Data.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"data\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode SectionResponse")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *SectionResponse) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SectionResponse) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *Story) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *Story) encodeFields(e *jx.Encoder) {
{
if s.Gid.Set {
e.FieldStart("gid")
s.Gid.Encode(e)
}
}
{
if s.ResourceType.Set {
e.FieldStart("resource_type")
s.ResourceType.Encode(e)
}
}
{
if s.Type.Set {
e.FieldStart("type")
s.Type.Encode(e)
}
}
{
if s.Text.Set {
e.FieldStart("text")
s.Text.Encode(e)
}
}
{
if s.CreatedAt.Set {
e.FieldStart("created_at")
s.CreatedAt.Encode(e)
}
}
{
if s.CreatedBy.Set {
e.FieldStart("created_by")
s.CreatedBy.Encode(e)
}
}
}
var jsonFieldsNameOfStory = [6]string{
0: "gid",
1: "resource_type",
2: "type",
3: "text",
4: "created_at",
5: "created_by",
}
// Decode decodes Story from json.
func (s *Story) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode Story to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "gid":
if err := func() error {
s.Gid.Reset()
if err := s.Gid.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"gid\"")
}
case "resource_type":
if err := func() error {
s.ResourceType.Reset()
if err := s.ResourceType.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"resource_type\"")
}
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 "text":
if err := func() error {
s.Text.Reset()
if err := s.Text.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"text\"")
}
case "created_at":
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 \"created_at\"")
}
case "created_by":
if err := func() error {
s.CreatedBy.Reset()
if err := s.CreatedBy.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"created_by\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode Story")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *Story) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Story) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *StoryCreatedBy) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *StoryCreatedBy) encodeFields(e *jx.Encoder) {
{
if s.Gid.Set {
e.FieldStart("gid")
s.Gid.Encode(e)
}
}
{
if s.Name.Set {
e.FieldStart("name")
s.Name.Encode(e)
}
}
}
var jsonFieldsNameOfStoryCreatedBy = [2]string{
0: "gid",
1: "name",
}
// Decode decodes StoryCreatedBy from json.
func (s *StoryCreatedBy) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode StoryCreatedBy to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "gid":
if err := func() error {
s.Gid.Reset()
if err := s.Gid.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"gid\"")
}
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\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode StoryCreatedBy")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *StoryCreatedBy) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *StoryCreatedBy) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *StoryListResponse) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *StoryListResponse) encodeFields(e *jx.Encoder) {
{
if s.Data != nil {
e.FieldStart("data")
e.ArrStart()
for _, elem := range s.Data {
elem.Encode(e)
}
e.ArrEnd()
}
}
}
var jsonFieldsNameOfStoryListResponse = [1]string{
0: "data",
}
// Decode decodes StoryListResponse from json.
func (s *StoryListResponse) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode StoryListResponse to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "data":
if err := func() error {
s.Data = make([]Story, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem Story
if err := elem.Decode(d); err != nil {
return err
}
s.Data = append(s.Data, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"data\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode StoryListResponse")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *StoryListResponse) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *StoryListResponse) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *StoryResponse) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *StoryResponse) encodeFields(e *jx.Encoder) {
{
if s.Data.Set {
e.FieldStart("data")
s.Data.Encode(e)
}
}
}
var jsonFieldsNameOfStoryResponse = [1]string{
0: "data",
}
// Decode decodes StoryResponse from json.
func (s *StoryResponse) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode StoryResponse to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "data":
if err := func() error {
s.Data.Reset()
if err := s.Data.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"data\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode StoryResponse")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *StoryResponse) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *StoryResponse) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *Tag) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *Tag) encodeFields(e *jx.Encoder) {
{
if s.Gid.Set {
e.FieldStart("gid")
s.Gid.Encode(e)
}
}
{
if s.Name.Set {
e.FieldStart("name")
s.Name.Encode(e)
}
}
{
if s.ResourceType.Set {
e.FieldStart("resource_type")
s.ResourceType.Encode(e)
}
}
{
if s.Color.Set {
e.FieldStart("color")
s.Color.Encode(e)
}
}
}
var jsonFieldsNameOfTag = [4]string{
0: "gid",
1: "name",
2: "resource_type",
3: "color",
}
// Decode decodes Tag from json.
func (s *Tag) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode Tag to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "gid":
if err := func() error {
s.Gid.Reset()
if err := s.Gid.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"gid\"")
}
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 "resource_type":
if err := func() error {
s.ResourceType.Reset()
if err := s.ResourceType.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"resource_type\"")
}
case "color":
if err := func() error {
s.Color.Reset()
if err := s.Color.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"color\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode Tag")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *Tag) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Tag) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *TagListResponse) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *TagListResponse) encodeFields(e *jx.Encoder) {
{
if s.Data != nil {
e.FieldStart("data")
e.ArrStart()
for _, elem := range s.Data {
elem.Encode(e)
}
e.ArrEnd()
}
}
}
var jsonFieldsNameOfTagListResponse = [1]string{
0: "data",
}
// Decode decodes TagListResponse from json.
func (s *TagListResponse) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode TagListResponse to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "data":
if err := func() error {
s.Data = make([]Tag, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem Tag
if err := elem.Decode(d); err != nil {
return err
}
s.Data = append(s.Data, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"data\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode TagListResponse")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *TagListResponse) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *TagListResponse) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *TagResponse) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *TagResponse) encodeFields(e *jx.Encoder) {
{
if s.Data.Set {
e.FieldStart("data")
s.Data.Encode(e)
}
}
}
var jsonFieldsNameOfTagResponse = [1]string{
0: "data",
}
// Decode decodes TagResponse from json.
func (s *TagResponse) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode TagResponse to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "data":
if err := func() error {
s.Data.Reset()
if err := s.Data.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"data\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode TagResponse")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *TagResponse) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *TagResponse) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *Task) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *Task) encodeFields(e *jx.Encoder) {
{
if s.Gid.Set {
e.FieldStart("gid")
s.Gid.Encode(e)
}
}
{
if s.Name.Set {
e.FieldStart("name")
s.Name.Encode(e)
}
}
{
if s.ResourceType.Set {
e.FieldStart("resource_type")
s.ResourceType.Encode(e)
}
}
{
if s.Completed.Set {
e.FieldStart("completed")
s.Completed.Encode(e)
}
}
{
if s.Notes.Set {
e.FieldStart("notes")
s.Notes.Encode(e)
}
}
{
if s.HTMLNotes.Set {
e.FieldStart("html_notes")
s.HTMLNotes.Encode(e)
}
}
{
if s.DueOn.Set {
e.FieldStart("due_on")
s.DueOn.Encode(e)
}
}
{
if s.DueAt.Set {
e.FieldStart("due_at")
s.DueAt.Encode(e)
}
}
{
if s.StartOn.Set {
e.FieldStart("start_on")
s.StartOn.Encode(e)
}
}
{
if s.CompletedAt.Set {
e.FieldStart("completed_at")
s.CompletedAt.Encode(e)
}
}
{
if s.CreatedAt.Set {
e.FieldStart("created_at")
s.CreatedAt.Encode(e)
}
}
{
if s.ModifiedAt.Set {
e.FieldStart("modified_at")
s.ModifiedAt.Encode(e)
}
}
{
if s.Assignee.Set {
e.FieldStart("assignee")
s.Assignee.Encode(e)
}
}
{
if s.Projects != nil {
e.FieldStart("projects")
e.ArrStart()
for _, elem := range s.Projects {
elem.Encode(e)
}
e.ArrEnd()
}
}
{
if s.Tags != nil {
e.FieldStart("tags")
e.ArrStart()
for _, elem := range s.Tags {
elem.Encode(e)
}
e.ArrEnd()
}
}
{
if s.Parent.Set {
e.FieldStart("parent")
s.Parent.Encode(e)
}
}
}
var jsonFieldsNameOfTask = [16]string{
0: "gid",
1: "name",
2: "resource_type",
3: "completed",
4: "notes",
5: "html_notes",
6: "due_on",
7: "due_at",
8: "start_on",
9: "completed_at",
10: "created_at",
11: "modified_at",
12: "assignee",
13: "projects",
14: "tags",
15: "parent",
}
// Decode decodes Task from json.
func (s *Task) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode Task to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "gid":
if err := func() error {
s.Gid.Reset()
if err := s.Gid.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"gid\"")
}
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 "resource_type":
if err := func() error {
s.ResourceType.Reset()
if err := s.ResourceType.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"resource_type\"")
}
case "completed":
if err := func() error {
s.Completed.Reset()
if err := s.Completed.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"completed\"")
}
case "notes":
if err := func() error {
s.Notes.Reset()
if err := s.Notes.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"notes\"")
}
case "html_notes":
if err := func() error {
s.HTMLNotes.Reset()
if err := s.HTMLNotes.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"html_notes\"")
}
case "due_on":
if err := func() error {
s.DueOn.Reset()
if err := s.DueOn.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"due_on\"")
}
case "due_at":
if err := func() error {
s.DueAt.Reset()
if err := s.DueAt.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"due_at\"")
}
case "start_on":
if err := func() error {
s.StartOn.Reset()
if err := s.StartOn.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"start_on\"")
}
case "completed_at":
if err := func() error {
s.CompletedAt.Reset()
if err := s.CompletedAt.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"completed_at\"")
}
case "created_at":
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 \"created_at\"")
}
case "modified_at":
if err := func() error {
s.ModifiedAt.Reset()
if err := s.ModifiedAt.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"modified_at\"")
}
case "assignee":
if err := func() error {
s.Assignee.Reset()
if err := s.Assignee.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"assignee\"")
}
case "projects":
if err := func() error {
s.Projects = make([]TaskProjectsItem, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem TaskProjectsItem
if err := elem.Decode(d); err != nil {
return err
}
s.Projects = append(s.Projects, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"projects\"")
}
case "tags":
if err := func() error {
s.Tags = make([]TaskTagsItem, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem TaskTagsItem
if err := elem.Decode(d); err != nil {
return err
}
s.Tags = append(s.Tags, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"tags\"")
}
case "parent":
if err := func() error {
s.Parent.Reset()
if err := s.Parent.Decode(d); 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 Task")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *Task) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Task) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *TaskAssignee) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *TaskAssignee) encodeFields(e *jx.Encoder) {
{
if s.Gid.Set {
e.FieldStart("gid")
s.Gid.Encode(e)
}
}
{
if s.Name.Set {
e.FieldStart("name")
s.Name.Encode(e)
}
}
}
var jsonFieldsNameOfTaskAssignee = [2]string{
0: "gid",
1: "name",
}
// Decode decodes TaskAssignee from json.
func (s *TaskAssignee) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode TaskAssignee to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "gid":
if err := func() error {
s.Gid.Reset()
if err := s.Gid.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"gid\"")
}
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\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode TaskAssignee")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *TaskAssignee) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *TaskAssignee) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *TaskListResponse) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *TaskListResponse) encodeFields(e *jx.Encoder) {
{
if s.Data != nil {
e.FieldStart("data")
e.ArrStart()
for _, elem := range s.Data {
elem.Encode(e)
}
e.ArrEnd()
}
}
}
var jsonFieldsNameOfTaskListResponse = [1]string{
0: "data",
}
// Decode decodes TaskListResponse from json.
func (s *TaskListResponse) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode TaskListResponse to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "data":
if err := func() error {
s.Data = make([]Task, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem Task
if err := elem.Decode(d); err != nil {
return err
}
s.Data = append(s.Data, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"data\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode TaskListResponse")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *TaskListResponse) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *TaskListResponse) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *TaskParent) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *TaskParent) encodeFields(e *jx.Encoder) {
{
if s.Gid.Set {
e.FieldStart("gid")
s.Gid.Encode(e)
}
}
{
if s.Name.Set {
e.FieldStart("name")
s.Name.Encode(e)
}
}
}
var jsonFieldsNameOfTaskParent = [2]string{
0: "gid",
1: "name",
}
// Decode decodes TaskParent from json.
func (s *TaskParent) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode TaskParent to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "gid":
if err := func() error {
s.Gid.Reset()
if err := s.Gid.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"gid\"")
}
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\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode TaskParent")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *TaskParent) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *TaskParent) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *TaskProjectsItem) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *TaskProjectsItem) encodeFields(e *jx.Encoder) {
{
if s.Gid.Set {
e.FieldStart("gid")
s.Gid.Encode(e)
}
}
{
if s.Name.Set {
e.FieldStart("name")
s.Name.Encode(e)
}
}
}
var jsonFieldsNameOfTaskProjectsItem = [2]string{
0: "gid",
1: "name",
}
// Decode decodes TaskProjectsItem from json.
func (s *TaskProjectsItem) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode TaskProjectsItem to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "gid":
if err := func() error {
s.Gid.Reset()
if err := s.Gid.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"gid\"")
}
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\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode TaskProjectsItem")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *TaskProjectsItem) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *TaskProjectsItem) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *TaskResponse) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *TaskResponse) encodeFields(e *jx.Encoder) {
{
if s.Data.Set {
e.FieldStart("data")
s.Data.Encode(e)
}
}
}
var jsonFieldsNameOfTaskResponse = [1]string{
0: "data",
}
// Decode decodes TaskResponse from json.
func (s *TaskResponse) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode TaskResponse to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "data":
if err := func() error {
s.Data.Reset()
if err := s.Data.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"data\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode TaskResponse")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *TaskResponse) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *TaskResponse) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *TaskTagsItem) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *TaskTagsItem) encodeFields(e *jx.Encoder) {
{
if s.Gid.Set {
e.FieldStart("gid")
s.Gid.Encode(e)
}
}
{
if s.Name.Set {
e.FieldStart("name")
s.Name.Encode(e)
}
}
}
var jsonFieldsNameOfTaskTagsItem = [2]string{
0: "gid",
1: "name",
}
// Decode decodes TaskTagsItem from json.
func (s *TaskTagsItem) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode TaskTagsItem to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "gid":
if err := func() error {
s.Gid.Reset()
if err := s.Gid.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"gid\"")
}
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\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode TaskTagsItem")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *TaskTagsItem) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *TaskTagsItem) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *UpdateProjectRequest) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *UpdateProjectRequest) encodeFields(e *jx.Encoder) {
{
e.FieldStart("data")
s.Data.Encode(e)
}
}
var jsonFieldsNameOfUpdateProjectRequest = [1]string{
0: "data",
}
// Decode decodes UpdateProjectRequest from json.
func (s *UpdateProjectRequest) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode UpdateProjectRequest to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "data":
requiredBitSet[0] |= 1 << 0
if err := func() error {
if err := s.Data.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"data\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode UpdateProjectRequest")
}
// 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(jsonFieldsNameOfUpdateProjectRequest) {
name = jsonFieldsNameOfUpdateProjectRequest[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 *UpdateProjectRequest) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UpdateProjectRequest) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *UpdateProjectRequestData) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *UpdateProjectRequestData) encodeFields(e *jx.Encoder) {
{
if s.Name.Set {
e.FieldStart("name")
s.Name.Encode(e)
}
}
{
if s.Notes.Set {
e.FieldStart("notes")
s.Notes.Encode(e)
}
}
{
if s.Color.Set {
e.FieldStart("color")
s.Color.Encode(e)
}
}
{
if s.DefaultView.Set {
e.FieldStart("default_view")
s.DefaultView.Encode(e)
}
}
{
if s.DueOn.Set {
e.FieldStart("due_on")
s.DueOn.Encode(e)
}
}
{
if s.Archived.Set {
e.FieldStart("archived")
s.Archived.Encode(e)
}
}
}
var jsonFieldsNameOfUpdateProjectRequestData = [6]string{
0: "name",
1: "notes",
2: "color",
3: "default_view",
4: "due_on",
5: "archived",
}
// Decode decodes UpdateProjectRequestData from json.
func (s *UpdateProjectRequestData) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode UpdateProjectRequestData to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "name":
if err := func() error {
s.Name.Reset()
if err := s.Name.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"name\"")
}
case "notes":
if err := func() error {
s.Notes.Reset()
if err := s.Notes.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"notes\"")
}
case "color":
if err := func() error {
s.Color.Reset()
if err := s.Color.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"color\"")
}
case "default_view":
if err := func() error {
s.DefaultView.Reset()
if err := s.DefaultView.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"default_view\"")
}
case "due_on":
if err := func() error {
s.DueOn.Reset()
if err := s.DueOn.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"due_on\"")
}
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 UpdateProjectRequestData")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *UpdateProjectRequestData) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UpdateProjectRequestData) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *UpdateTaskRequest) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *UpdateTaskRequest) encodeFields(e *jx.Encoder) {
{
e.FieldStart("data")
s.Data.Encode(e)
}
}
var jsonFieldsNameOfUpdateTaskRequest = [1]string{
0: "data",
}
// Decode decodes UpdateTaskRequest from json.
func (s *UpdateTaskRequest) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode UpdateTaskRequest to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "data":
requiredBitSet[0] |= 1 << 0
if err := func() error {
if err := s.Data.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"data\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode UpdateTaskRequest")
}
// 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(jsonFieldsNameOfUpdateTaskRequest) {
name = jsonFieldsNameOfUpdateTaskRequest[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 *UpdateTaskRequest) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UpdateTaskRequest) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *UpdateTaskRequestData) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *UpdateTaskRequestData) encodeFields(e *jx.Encoder) {
{
if s.Name.Set {
e.FieldStart("name")
s.Name.Encode(e)
}
}
{
if s.Notes.Set {
e.FieldStart("notes")
s.Notes.Encode(e)
}
}
{
if s.HTMLNotes.Set {
e.FieldStart("html_notes")
s.HTMLNotes.Encode(e)
}
}
{
if s.DueOn.Set {
e.FieldStart("due_on")
s.DueOn.Encode(e)
}
}
{
if s.DueAt.Set {
e.FieldStart("due_at")
s.DueAt.Encode(e)
}
}
{
if s.StartOn.Set {
e.FieldStart("start_on")
s.StartOn.Encode(e)
}
}
{
if s.Completed.Set {
e.FieldStart("completed")
s.Completed.Encode(e)
}
}
{
if s.Assignee.Set {
e.FieldStart("assignee")
s.Assignee.Encode(e)
}
}
}
var jsonFieldsNameOfUpdateTaskRequestData = [8]string{
0: "name",
1: "notes",
2: "html_notes",
3: "due_on",
4: "due_at",
5: "start_on",
6: "completed",
7: "assignee",
}
// Decode decodes UpdateTaskRequestData from json.
func (s *UpdateTaskRequestData) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode UpdateTaskRequestData to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "name":
if err := func() error {
s.Name.Reset()
if err := s.Name.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"name\"")
}
case "notes":
if err := func() error {
s.Notes.Reset()
if err := s.Notes.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"notes\"")
}
case "html_notes":
if err := func() error {
s.HTMLNotes.Reset()
if err := s.HTMLNotes.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"html_notes\"")
}
case "due_on":
if err := func() error {
s.DueOn.Reset()
if err := s.DueOn.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"due_on\"")
}
case "due_at":
if err := func() error {
s.DueAt.Reset()
if err := s.DueAt.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"due_at\"")
}
case "start_on":
if err := func() error {
s.StartOn.Reset()
if err := s.StartOn.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"start_on\"")
}
case "completed":
if err := func() error {
s.Completed.Reset()
if err := s.Completed.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"completed\"")
}
case "assignee":
if err := func() error {
s.Assignee.Reset()
if err := s.Assignee.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"assignee\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode UpdateTaskRequestData")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *UpdateTaskRequestData) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UpdateTaskRequestData) 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.Gid.Set {
e.FieldStart("gid")
s.Gid.Encode(e)
}
}
{
if s.Name.Set {
e.FieldStart("name")
s.Name.Encode(e)
}
}
{
if s.Email.Set {
e.FieldStart("email")
s.Email.Encode(e)
}
}
{
if s.ResourceType.Set {
e.FieldStart("resource_type")
s.ResourceType.Encode(e)
}
}
}
var jsonFieldsNameOfUser = [4]string{
0: "gid",
1: "name",
2: "email",
3: "resource_type",
}
// 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 "gid":
if err := func() error {
s.Gid.Reset()
if err := s.Gid.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"gid\"")
}
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 "email":
if err := func() error {
s.Email.Reset()
if err := s.Email.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"email\"")
}
case "resource_type":
if err := func() error {
s.ResourceType.Reset()
if err := s.ResourceType.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"resource_type\"")
}
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)
}
// Encode implements json.Marshaler.
func (s *UserResponse) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *UserResponse) encodeFields(e *jx.Encoder) {
{
if s.Data.Set {
e.FieldStart("data")
s.Data.Encode(e)
}
}
}
var jsonFieldsNameOfUserResponse = [1]string{
0: "data",
}
// Decode decodes UserResponse from json.
func (s *UserResponse) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode UserResponse to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "data":
if err := func() error {
s.Data.Reset()
if err := s.Data.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"data\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode UserResponse")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *UserResponse) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UserResponse) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *Workspace) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *Workspace) encodeFields(e *jx.Encoder) {
{
if s.Gid.Set {
e.FieldStart("gid")
s.Gid.Encode(e)
}
}
{
if s.Name.Set {
e.FieldStart("name")
s.Name.Encode(e)
}
}
{
if s.ResourceType.Set {
e.FieldStart("resource_type")
s.ResourceType.Encode(e)
}
}
{
if s.IsOrganization.Set {
e.FieldStart("is_organization")
s.IsOrganization.Encode(e)
}
}
}
var jsonFieldsNameOfWorkspace = [4]string{
0: "gid",
1: "name",
2: "resource_type",
3: "is_organization",
}
// Decode decodes Workspace from json.
func (s *Workspace) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode Workspace to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "gid":
if err := func() error {
s.Gid.Reset()
if err := s.Gid.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"gid\"")
}
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 "resource_type":
if err := func() error {
s.ResourceType.Reset()
if err := s.ResourceType.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"resource_type\"")
}
case "is_organization":
if err := func() error {
s.IsOrganization.Reset()
if err := s.IsOrganization.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"is_organization\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode Workspace")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *Workspace) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Workspace) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *WorkspaceListResponse) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *WorkspaceListResponse) encodeFields(e *jx.Encoder) {
{
if s.Data != nil {
e.FieldStart("data")
e.ArrStart()
for _, elem := range s.Data {
elem.Encode(e)
}
e.ArrEnd()
}
}
}
var jsonFieldsNameOfWorkspaceListResponse = [1]string{
0: "data",
}
// Decode decodes WorkspaceListResponse from json.
func (s *WorkspaceListResponse) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode WorkspaceListResponse to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "data":
if err := func() error {
s.Data = make([]Workspace, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem Workspace
if err := elem.Decode(d); err != nil {
return err
}
s.Data = append(s.Data, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"data\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode WorkspaceListResponse")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *WorkspaceListResponse) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *WorkspaceListResponse) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *WorkspaceResponse) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *WorkspaceResponse) encodeFields(e *jx.Encoder) {
{
if s.Data.Set {
e.FieldStart("data")
s.Data.Encode(e)
}
}
}
var jsonFieldsNameOfWorkspaceResponse = [1]string{
0: "data",
}
// Decode decodes WorkspaceResponse from json.
func (s *WorkspaceResponse) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode WorkspaceResponse to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "data":
if err := func() error {
s.Data.Reset()
if err := s.Data.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"data\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode WorkspaceResponse")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *WorkspaceResponse) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *WorkspaceResponse) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
