// Code generated by ogen, DO NOT EDIT.
package gen
import (
"math/bits"
"strconv"
"time"
"github.com/go-faster/errors"
"github.com/go-faster/jx"
"github.com/ogen-go/ogen/json"
"github.com/ogen-go/ogen/validate"
)
// Encode implements json.Marshaler.
func (s *ApiKey) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *ApiKey) encodeFields(e *jx.Encoder) {
{
e.FieldStart("id")
e.Str(s.ID)
}
{
e.FieldStart("key_prefix")
e.Str(s.KeyPrefix)
}
{
e.FieldStart("display_name")
e.Str(s.DisplayName)
}
{
if s.ExpiresAt.Set {
e.FieldStart("expires_at")
s.ExpiresAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.LastUsedAt.Set {
e.FieldStart("last_used_at")
s.LastUsedAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.RevokedAt.Set {
e.FieldStart("revoked_at")
s.RevokedAt.Encode(e, json.EncodeDateTime)
}
}
}
var jsonFieldsNameOfApiKey = [6]string{
0: "id",
1: "key_prefix",
2: "display_name",
3: "expires_at",
4: "last_used_at",
5: "revoked_at",
}
// Decode decodes ApiKey from json.
func (s *ApiKey) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode ApiKey to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "id":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Str()
s.ID = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"id\"")
}
case "key_prefix":
requiredBitSet[0] |= 1 << 1
if err := func() error {
v, err := d.Str()
s.KeyPrefix = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"key_prefix\"")
}
case "display_name":
requiredBitSet[0] |= 1 << 2
if err := func() error {
v, err := d.Str()
s.DisplayName = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"display_name\"")
}
case "expires_at":
if err := func() error {
s.ExpiresAt.Reset()
if err := s.ExpiresAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"expires_at\"")
}
case "last_used_at":
if err := func() error {
s.LastUsedAt.Reset()
if err := s.LastUsedAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"last_used_at\"")
}
case "revoked_at":
if err := func() error {
s.RevokedAt.Reset()
if err := s.RevokedAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"revoked_at\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode ApiKey")
}
// Validate required fields.
var failures []validate.FieldError
for i, mask := range [1]uint8{
0b00000111,
} {
if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
// Mask only required fields and check equality to mask using XOR.
//
// If XOR result is not zero, result is not equal to expected, so some fields are missed.
// Bits of fields which would be set are actually bits of missed fields.
missed := bits.OnesCount8(result)
for bitN := 0; bitN < missed; bitN++ {
bitIdx := bits.TrailingZeros8(result)
fieldIdx := i*8 + bitIdx
var name string
if fieldIdx < len(jsonFieldsNameOfApiKey) {
name = jsonFieldsNameOfApiKey[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 *ApiKey) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ApiKey) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *ApiKeyStatus) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *ApiKeyStatus) encodeFields(e *jx.Encoder) {
{
e.FieldStart("active")
e.Bool(s.Active)
}
{
e.FieldStart("key_id")
e.Str(s.KeyID)
}
{
e.FieldStart("user_id")
e.Str(s.UserID)
}
{
if s.ExpiresAt.Set {
e.FieldStart("expires_at")
s.ExpiresAt.Encode(e, json.EncodeDateTime)
}
}
}
var jsonFieldsNameOfApiKeyStatus = [4]string{
0: "active",
1: "key_id",
2: "user_id",
3: "expires_at",
}
// Decode decodes ApiKeyStatus from json.
func (s *ApiKeyStatus) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode ApiKeyStatus to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "active":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Bool()
s.Active = bool(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"active\"")
}
case "key_id":
requiredBitSet[0] |= 1 << 1
if err := func() error {
v, err := d.Str()
s.KeyID = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"key_id\"")
}
case "user_id":
requiredBitSet[0] |= 1 << 2
if err := func() error {
v, err := d.Str()
s.UserID = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"user_id\"")
}
case "expires_at":
if err := func() error {
s.ExpiresAt.Reset()
if err := s.ExpiresAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"expires_at\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode ApiKeyStatus")
}
// Validate required fields.
var failures []validate.FieldError
for i, mask := range [1]uint8{
0b00000111,
} {
if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
// Mask only required fields and check equality to mask using XOR.
//
// If XOR result is not zero, result is not equal to expected, so some fields are missed.
// Bits of fields which would be set are actually bits of missed fields.
missed := bits.OnesCount8(result)
for bitN := 0; bitN < missed; bitN++ {
bitIdx := bits.TrailingZeros8(result)
fieldIdx := i*8 + bitIdx
var name string
if fieldIdx < len(jsonFieldsNameOfApiKeyStatus) {
name = jsonFieldsNameOfApiKeyStatus[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 *ApiKeyStatus) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ApiKeyStatus) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *CompleteOnboardingBody) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *CompleteOnboardingBody) encodeFields(e *jx.Encoder) {
{
e.FieldStart("event_id")
e.Str(s.EventID)
}
}
var jsonFieldsNameOfCompleteOnboardingBody = [1]string{
0: "event_id",
}
// Decode decodes CompleteOnboardingBody from json.
func (s *CompleteOnboardingBody) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode CompleteOnboardingBody to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "event_id":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Str()
s.EventID = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"event_id\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode CompleteOnboardingBody")
}
// 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(jsonFieldsNameOfCompleteOnboardingBody) {
name = jsonFieldsNameOfCompleteOnboardingBody[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 *CompleteOnboardingBody) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CompleteOnboardingBody) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *CreatePromptBody) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *CreatePromptBody) encodeFields(e *jx.Encoder) {
{
e.FieldStart("name")
e.Str(s.Name)
}
{
e.FieldStart("content")
e.Str(s.Content)
}
{
if s.ModuleName.Set {
e.FieldStart("module_name")
s.ModuleName.Encode(e)
}
}
{
e.FieldStart("enabled")
e.Bool(s.Enabled)
}
{
if s.Description.Set {
e.FieldStart("description")
s.Description.Encode(e)
}
}
}
var jsonFieldsNameOfCreatePromptBody = [5]string{
0: "name",
1: "content",
2: "module_name",
3: "enabled",
4: "description",
}
// Decode decodes CreatePromptBody from json.
func (s *CreatePromptBody) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode CreatePromptBody to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "name":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Str()
s.Name = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"name\"")
}
case "content":
requiredBitSet[0] |= 1 << 1
if err := func() error {
v, err := d.Str()
s.Content = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"content\"")
}
case "module_name":
if err := func() error {
s.ModuleName.Reset()
if err := s.ModuleName.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"module_name\"")
}
case "enabled":
requiredBitSet[0] |= 1 << 3
if err := func() error {
v, err := d.Bool()
s.Enabled = bool(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"enabled\"")
}
case "description":
if err := func() error {
s.Description.Reset()
if err := s.Description.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"description\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode CreatePromptBody")
}
// Validate required fields.
var failures []validate.FieldError
for i, mask := range [1]uint8{
0b00001011,
} {
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(jsonFieldsNameOfCreatePromptBody) {
name = jsonFieldsNameOfCreatePromptBody[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 *CreatePromptBody) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CreatePromptBody) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *Credential) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *Credential) encodeFields(e *jx.Encoder) {
{
e.FieldStart("module")
e.Str(s.Module)
}
{
e.FieldStart("created_at")
json.EncodeDateTime(e, s.CreatedAt)
}
{
e.FieldStart("updated_at")
json.EncodeDateTime(e, s.UpdatedAt)
}
}
var jsonFieldsNameOfCredential = [3]string{
0: "module",
1: "created_at",
2: "updated_at",
}
// Decode decodes Credential from json.
func (s *Credential) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode Credential to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "module":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Str()
s.Module = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"module\"")
}
case "created_at":
requiredBitSet[0] |= 1 << 1
if err := func() error {
v, err := json.DecodeDateTime(d)
s.CreatedAt = v
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"created_at\"")
}
case "updated_at":
requiredBitSet[0] |= 1 << 2
if err := func() error {
v, err := json.DecodeDateTime(d)
s.UpdatedAt = v
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"updated_at\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode Credential")
}
// Validate required fields.
var failures []validate.FieldError
for i, mask := range [1]uint8{
0b00000111,
} {
if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
// Mask only required fields and check equality to mask using XOR.
//
// If XOR result is not zero, result is not equal to expected, so some fields are missed.
// Bits of fields which would be set are actually bits of missed fields.
missed := bits.OnesCount8(result)
for bitN := 0; bitN < missed; bitN++ {
bitIdx := bits.TrailingZeros8(result)
fieldIdx := i*8 + bitIdx
var name string
if fieldIdx < len(jsonFieldsNameOfCredential) {
name = jsonFieldsNameOfCredential[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 *Credential) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Credential) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *DeletePromptResult) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *DeletePromptResult) encodeFields(e *jx.Encoder) {
{
e.FieldStart("success")
e.Bool(s.Success)
}
{
if s.Error.Set {
e.FieldStart("error")
s.Error.Encode(e)
}
}
}
var jsonFieldsNameOfDeletePromptResult = [2]string{
0: "success",
1: "error",
}
// Decode decodes DeletePromptResult from json.
func (s *DeletePromptResult) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode DeletePromptResult to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "success":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Bool()
s.Success = bool(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"success\"")
}
case "error":
if err := func() error {
s.Error.Reset()
if err := s.Error.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"error\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode DeletePromptResult")
}
// 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(jsonFieldsNameOfDeletePromptResult) {
name = jsonFieldsNameOfDeletePromptResult[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 *DeletePromptResult) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *DeletePromptResult) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *ErrorResponse) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *ErrorResponse) encodeFields(e *jx.Encoder) {
{
e.FieldStart("error")
e.Str(s.Error)
}
}
var jsonFieldsNameOfErrorResponse = [1]string{
0: "error",
}
// Decode decodes ErrorResponse from json.
func (s *ErrorResponse) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode ErrorResponse to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "error":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Str()
s.Error = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"error\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode ErrorResponse")
}
// 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(jsonFieldsNameOfErrorResponse) {
name = jsonFieldsNameOfErrorResponse[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 *ErrorResponse) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ErrorResponse) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *GenerateApiKeyBody) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *GenerateApiKeyBody) encodeFields(e *jx.Encoder) {
{
e.FieldStart("display_name")
e.Str(s.DisplayName)
}
{
if s.ExpiresAt.Set {
e.FieldStart("expires_at")
s.ExpiresAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.NoExpiry.Set {
e.FieldStart("no_expiry")
s.NoExpiry.Encode(e)
}
}
}
var jsonFieldsNameOfGenerateApiKeyBody = [3]string{
0: "display_name",
1: "expires_at",
2: "no_expiry",
}
// Decode decodes GenerateApiKeyBody from json.
func (s *GenerateApiKeyBody) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode GenerateApiKeyBody to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "display_name":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Str()
s.DisplayName = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"display_name\"")
}
case "expires_at":
if err := func() error {
s.ExpiresAt.Reset()
if err := s.ExpiresAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"expires_at\"")
}
case "no_expiry":
if err := func() error {
s.NoExpiry.Reset()
if err := s.NoExpiry.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"no_expiry\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode GenerateApiKeyBody")
}
// 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(jsonFieldsNameOfGenerateApiKeyBody) {
name = jsonFieldsNameOfGenerateApiKeyBody[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 *GenerateApiKeyBody) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *GenerateApiKeyBody) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *GenerateApiKeyResult) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *GenerateApiKeyResult) encodeFields(e *jx.Encoder) {
{
e.FieldStart("api_key")
e.Str(s.APIKey)
}
{
e.FieldStart("key_prefix")
e.Str(s.KeyPrefix)
}
}
var jsonFieldsNameOfGenerateApiKeyResult = [2]string{
0: "api_key",
1: "key_prefix",
}
// Decode decodes GenerateApiKeyResult from json.
func (s *GenerateApiKeyResult) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode GenerateApiKeyResult to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "api_key":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Str()
s.APIKey = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"api_key\"")
}
case "key_prefix":
requiredBitSet[0] |= 1 << 1
if err := func() error {
v, err := d.Str()
s.KeyPrefix = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"key_prefix\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode GenerateApiKeyResult")
}
// Validate required fields.
var failures []validate.FieldError
for i, mask := range [1]uint8{
0b00000011,
} {
if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
// Mask only required fields and check equality to mask using XOR.
//
// If XOR result is not zero, result is not equal to expected, so some fields are missed.
// Bits of fields which would be set are actually bits of missed fields.
missed := bits.OnesCount8(result)
for bitN := 0; bitN < missed; bitN++ {
bitIdx := bits.TrailingZeros8(result)
fieldIdx := i*8 + bitIdx
var name string
if fieldIdx < len(jsonFieldsNameOfGenerateApiKeyResult) {
name = jsonFieldsNameOfGenerateApiKeyResult[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 *GenerateApiKeyResult) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *GenerateApiKeyResult) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *GetPromptResult) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *GetPromptResult) encodeFields(e *jx.Encoder) {
{
e.FieldStart("found")
e.Bool(s.Found)
}
{
if s.ID.Set {
e.FieldStart("id")
s.ID.Encode(e)
}
}
{
if s.ModuleName.Set {
e.FieldStart("module_name")
s.ModuleName.Encode(e)
}
}
{
if s.Name.Set {
e.FieldStart("name")
s.Name.Encode(e)
}
}
{
if s.Description.Set {
e.FieldStart("description")
s.Description.Encode(e)
}
}
{
if s.Content.Set {
e.FieldStart("content")
s.Content.Encode(e)
}
}
{
if s.Enabled.Set {
e.FieldStart("enabled")
s.Enabled.Encode(e)
}
}
{
if s.CreatedAt.Set {
e.FieldStart("created_at")
s.CreatedAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.UpdatedAt.Set {
e.FieldStart("updated_at")
s.UpdatedAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.Error.Set {
e.FieldStart("error")
s.Error.Encode(e)
}
}
}
var jsonFieldsNameOfGetPromptResult = [10]string{
0: "found",
1: "id",
2: "module_name",
3: "name",
4: "description",
5: "content",
6: "enabled",
7: "created_at",
8: "updated_at",
9: "error",
}
// Decode decodes GetPromptResult from json.
func (s *GetPromptResult) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode GetPromptResult to nil")
}
var requiredBitSet [2]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "found":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Bool()
s.Found = bool(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"found\"")
}
case "id":
if err := func() error {
s.ID.Reset()
if err := s.ID.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"id\"")
}
case "module_name":
if err := func() error {
s.ModuleName.Reset()
if err := s.ModuleName.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"module_name\"")
}
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 "description":
if err := func() error {
s.Description.Reset()
if err := s.Description.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"description\"")
}
case "content":
if err := func() error {
s.Content.Reset()
if err := s.Content.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"content\"")
}
case "enabled":
if err := func() error {
s.Enabled.Reset()
if err := s.Enabled.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"enabled\"")
}
case "created_at":
if err := func() error {
s.CreatedAt.Reset()
if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"created_at\"")
}
case "updated_at":
if err := func() error {
s.UpdatedAt.Reset()
if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"updated_at\"")
}
case "error":
if err := func() error {
s.Error.Reset()
if err := s.Error.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"error\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode GetPromptResult")
}
// Validate required fields.
var failures []validate.FieldError
for i, mask := range [2]uint8{
0b00000001,
0b00000000,
} {
if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
// Mask only required fields and check equality to mask using XOR.
//
// If XOR result is not zero, result is not equal to expected, so some fields are missed.
// Bits of fields which would be set are actually bits of missed fields.
missed := bits.OnesCount8(result)
for bitN := 0; bitN < missed; bitN++ {
bitIdx := bits.TrailingZeros8(result)
fieldIdx := i*8 + bitIdx
var name string
if fieldIdx < len(jsonFieldsNameOfGetPromptResult) {
name = jsonFieldsNameOfGetPromptResult[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 *GetPromptResult) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *GetPromptResult) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *LinkStripeCustomerBody) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *LinkStripeCustomerBody) encodeFields(e *jx.Encoder) {
{
e.FieldStart("stripe_customer_id")
e.Str(s.StripeCustomerID)
}
}
var jsonFieldsNameOfLinkStripeCustomerBody = [1]string{
0: "stripe_customer_id",
}
// Decode decodes LinkStripeCustomerBody from json.
func (s *LinkStripeCustomerBody) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode LinkStripeCustomerBody to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "stripe_customer_id":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Str()
s.StripeCustomerID = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"stripe_customer_id\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode LinkStripeCustomerBody")
}
// 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(jsonFieldsNameOfLinkStripeCustomerBody) {
name = jsonFieldsNameOfLinkStripeCustomerBody[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 *LinkStripeCustomerBody) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *LinkStripeCustomerBody) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *ModuleConfig) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *ModuleConfig) encodeFields(e *jx.Encoder) {
{
e.FieldStart("module_name")
e.Str(s.ModuleName)
}
{
if s.Description.Set {
e.FieldStart("description")
s.Description.Encode(e)
}
}
{
e.FieldStart("tool_id")
e.Str(s.ToolID)
}
{
e.FieldStart("enabled")
e.Bool(s.Enabled)
}
}
var jsonFieldsNameOfModuleConfig = [4]string{
0: "module_name",
1: "description",
2: "tool_id",
3: "enabled",
}
// Decode decodes ModuleConfig from json.
func (s *ModuleConfig) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode ModuleConfig to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "module_name":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Str()
s.ModuleName = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"module_name\"")
}
case "description":
if err := func() error {
s.Description.Reset()
if err := s.Description.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"description\"")
}
case "tool_id":
requiredBitSet[0] |= 1 << 2
if err := func() error {
v, err := d.Str()
s.ToolID = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"tool_id\"")
}
case "enabled":
requiredBitSet[0] |= 1 << 3
if err := func() error {
v, err := d.Bool()
s.Enabled = bool(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"enabled\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode ModuleConfig")
}
// Validate required fields.
var failures []validate.FieldError
for i, mask := range [1]uint8{
0b00001101,
} {
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(jsonFieldsNameOfModuleConfig) {
name = jsonFieldsNameOfModuleConfig[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 *ModuleConfig) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ModuleConfig) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *ModuleWithTools) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *ModuleWithTools) encodeFields(e *jx.Encoder) {
{
e.FieldStart("id")
e.Str(s.ID)
}
{
e.FieldStart("name")
e.Str(s.Name)
}
{
e.FieldStart("status")
e.Str(s.Status)
}
{
if s.Descriptions.Set {
e.FieldStart("descriptions")
s.Descriptions.Encode(e)
}
}
{
e.FieldStart("tools")
e.ArrStart()
for _, elem := range s.Tools {
if len(elem) != 0 {
e.Raw(elem)
}
}
e.ArrEnd()
}
}
var jsonFieldsNameOfModuleWithTools = [5]string{
0: "id",
1: "name",
2: "status",
3: "descriptions",
4: "tools",
}
// Decode decodes ModuleWithTools from json.
func (s *ModuleWithTools) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode ModuleWithTools to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "id":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Str()
s.ID = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"id\"")
}
case "name":
requiredBitSet[0] |= 1 << 1
if err := func() error {
v, err := d.Str()
s.Name = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"name\"")
}
case "status":
requiredBitSet[0] |= 1 << 2
if err := func() error {
v, err := d.Str()
s.Status = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"status\"")
}
case "descriptions":
if err := func() error {
s.Descriptions.Reset()
if err := s.Descriptions.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"descriptions\"")
}
case "tools":
requiredBitSet[0] |= 1 << 4
if err := func() error {
s.Tools = make([]jx.Raw, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem jx.Raw
v, err := d.RawAppend(nil)
elem = jx.Raw(v)
if err != nil {
return err
}
s.Tools = append(s.Tools, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"tools\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode ModuleWithTools")
}
// Validate required fields.
var failures []validate.FieldError
for i, mask := range [1]uint8{
0b00010111,
} {
if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
// Mask only required fields and check equality to mask using XOR.
//
// If XOR result is not zero, result is not equal to expected, so some fields are missed.
// Bits of fields which would be set are actually bits of missed fields.
missed := bits.OnesCount8(result)
for bitN := 0; bitN < missed; bitN++ {
bitIdx := bits.TrailingZeros8(result)
fieldIdx := i*8 + bitIdx
var name string
if fieldIdx < len(jsonFieldsNameOfModuleWithTools) {
name = jsonFieldsNameOfModuleWithTools[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 *ModuleWithTools) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ModuleWithTools) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s ModuleWithToolsDescriptions) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields implements json.Marshaler.
func (s ModuleWithToolsDescriptions) encodeFields(e *jx.Encoder) {
for k, elem := range s {
e.FieldStart(k)
e.Str(elem)
}
}
// Decode decodes ModuleWithToolsDescriptions from json.
func (s *ModuleWithToolsDescriptions) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode ModuleWithToolsDescriptions to nil")
}
m := s.init()
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
var elem string
if err := func() error {
v, err := d.Str()
elem = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrapf(err, "decode field %q", k)
}
m[string(k)] = elem
return nil
}); err != nil {
return errors.Wrap(err, "decode ModuleWithToolsDescriptions")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s ModuleWithToolsDescriptions) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ModuleWithToolsDescriptions) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *OAuthApp) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *OAuthApp) encodeFields(e *jx.Encoder) {
{
if s.Provider.Set {
e.FieldStart("provider")
s.Provider.Encode(e)
}
}
{
if s.ClientID.Set {
e.FieldStart("client_id")
s.ClientID.Encode(e)
}
}
{
if s.RedirectURI.Set {
e.FieldStart("redirect_uri")
s.RedirectURI.Encode(e)
}
}
{
if s.Enabled.Set {
e.FieldStart("enabled")
s.Enabled.Encode(e)
}
}
{
if s.CreatedAt.Set {
e.FieldStart("created_at")
s.CreatedAt.Encode(e, json.EncodeDateTime)
}
}
}
var jsonFieldsNameOfOAuthApp = [5]string{
0: "provider",
1: "client_id",
2: "redirect_uri",
3: "enabled",
4: "created_at",
}
// Decode decodes OAuthApp from json.
func (s *OAuthApp) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode OAuthApp to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "provider":
if err := func() error {
s.Provider.Reset()
if err := s.Provider.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"provider\"")
}
case "client_id":
if err := func() error {
s.ClientID.Reset()
if err := s.ClientID.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"client_id\"")
}
case "redirect_uri":
if err := func() error {
s.RedirectURI.Reset()
if err := s.RedirectURI.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"redirect_uri\"")
}
case "enabled":
if err := func() error {
s.Enabled.Reset()
if err := s.Enabled.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"enabled\"")
}
case "created_at":
if err := func() error {
s.CreatedAt.Reset()
if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"created_at\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode OAuthApp")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *OAuthApp) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OAuthApp) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *OAuthAppCredentials) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *OAuthAppCredentials) encodeFields(e *jx.Encoder) {
{
if s.Provider.Set {
e.FieldStart("provider")
s.Provider.Encode(e)
}
}
{
e.FieldStart("client_id")
e.Str(s.ClientID)
}
{
e.FieldStart("client_secret")
e.Str(s.ClientSecret)
}
{
e.FieldStart("redirect_uri")
e.Str(s.RedirectURI)
}
{
if s.Error.Set {
e.FieldStart("error")
s.Error.Encode(e)
}
}
{
if s.Message.Set {
e.FieldStart("message")
s.Message.Encode(e)
}
}
}
var jsonFieldsNameOfOAuthAppCredentials = [6]string{
0: "provider",
1: "client_id",
2: "client_secret",
3: "redirect_uri",
4: "error",
5: "message",
}
// Decode decodes OAuthAppCredentials from json.
func (s *OAuthAppCredentials) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode OAuthAppCredentials to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "provider":
if err := func() error {
s.Provider.Reset()
if err := s.Provider.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"provider\"")
}
case "client_id":
requiredBitSet[0] |= 1 << 1
if err := func() error {
v, err := d.Str()
s.ClientID = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"client_id\"")
}
case "client_secret":
requiredBitSet[0] |= 1 << 2
if err := func() error {
v, err := d.Str()
s.ClientSecret = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"client_secret\"")
}
case "redirect_uri":
requiredBitSet[0] |= 1 << 3
if err := func() error {
v, err := d.Str()
s.RedirectURI = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"redirect_uri\"")
}
case "error":
if err := func() error {
s.Error.Reset()
if err := s.Error.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"error\"")
}
case "message":
if err := func() error {
s.Message.Reset()
if err := s.Message.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"message\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode OAuthAppCredentials")
}
// Validate required fields.
var failures []validate.FieldError
for i, mask := range [1]uint8{
0b00001110,
} {
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(jsonFieldsNameOfOAuthAppCredentials) {
name = jsonFieldsNameOfOAuthAppCredentials[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 *OAuthAppCredentials) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OAuthAppCredentials) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *OAuthConsent) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *OAuthConsent) encodeFields(e *jx.Encoder) {
{
e.FieldStart("id")
e.Str(s.ID)
}
{
e.FieldStart("client_id")
e.Str(s.ClientID)
}
{
if s.ClientName.Set {
e.FieldStart("client_name")
s.ClientName.Encode(e)
}
}
{
e.FieldStart("scopes")
e.Str(s.Scopes)
}
{
e.FieldStart("granted_at")
json.EncodeDateTime(e, s.GrantedAt)
}
}
var jsonFieldsNameOfOAuthConsent = [5]string{
0: "id",
1: "client_id",
2: "client_name",
3: "scopes",
4: "granted_at",
}
// Decode decodes OAuthConsent from json.
func (s *OAuthConsent) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode OAuthConsent to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "id":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Str()
s.ID = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"id\"")
}
case "client_id":
requiredBitSet[0] |= 1 << 1
if err := func() error {
v, err := d.Str()
s.ClientID = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"client_id\"")
}
case "client_name":
if err := func() error {
s.ClientName.Reset()
if err := s.ClientName.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"client_name\"")
}
case "scopes":
requiredBitSet[0] |= 1 << 3
if err := func() error {
v, err := d.Str()
s.Scopes = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"scopes\"")
}
case "granted_at":
requiredBitSet[0] |= 1 << 4
if err := func() error {
v, err := json.DecodeDateTime(d)
s.GrantedAt = v
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"granted_at\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode OAuthConsent")
}
// Validate required fields.
var failures []validate.FieldError
for i, mask := range [1]uint8{
0b00011011,
} {
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(jsonFieldsNameOfOAuthConsent) {
name = jsonFieldsNameOfOAuthConsent[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 *OAuthConsent) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OAuthConsent) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *OAuthConsentAdmin) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *OAuthConsentAdmin) encodeFields(e *jx.Encoder) {
{
e.FieldStart("id")
e.Str(s.ID)
}
{
e.FieldStart("user_id")
e.Str(s.UserID)
}
{
if s.UserEmail.Set {
e.FieldStart("user_email")
s.UserEmail.Encode(e)
}
}
{
e.FieldStart("client_id")
e.Str(s.ClientID)
}
{
if s.ClientName.Set {
e.FieldStart("client_name")
s.ClientName.Encode(e)
}
}
{
e.FieldStart("scopes")
e.Str(s.Scopes)
}
{
e.FieldStart("granted_at")
json.EncodeDateTime(e, s.GrantedAt)
}
}
var jsonFieldsNameOfOAuthConsentAdmin = [7]string{
0: "id",
1: "user_id",
2: "user_email",
3: "client_id",
4: "client_name",
5: "scopes",
6: "granted_at",
}
// Decode decodes OAuthConsentAdmin from json.
func (s *OAuthConsentAdmin) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode OAuthConsentAdmin to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "id":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Str()
s.ID = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"id\"")
}
case "user_id":
requiredBitSet[0] |= 1 << 1
if err := func() error {
v, err := d.Str()
s.UserID = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"user_id\"")
}
case "user_email":
if err := func() error {
s.UserEmail.Reset()
if err := s.UserEmail.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"user_email\"")
}
case "client_id":
requiredBitSet[0] |= 1 << 3
if err := func() error {
v, err := d.Str()
s.ClientID = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"client_id\"")
}
case "client_name":
if err := func() error {
s.ClientName.Reset()
if err := s.ClientName.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"client_name\"")
}
case "scopes":
requiredBitSet[0] |= 1 << 5
if err := func() error {
v, err := d.Str()
s.Scopes = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"scopes\"")
}
case "granted_at":
requiredBitSet[0] |= 1 << 6
if err := func() error {
v, err := json.DecodeDateTime(d)
s.GrantedAt = v
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"granted_at\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode OAuthConsentAdmin")
}
// Validate required fields.
var failures []validate.FieldError
for i, mask := range [1]uint8{
0b01101011,
} {
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(jsonFieldsNameOfOAuthConsentAdmin) {
name = jsonFieldsNameOfOAuthConsentAdmin[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 *OAuthConsentAdmin) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OAuthConsentAdmin) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *OnboardingResult) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *OnboardingResult) encodeFields(e *jx.Encoder) {
{
e.FieldStart("success")
e.Bool(s.Success)
}
{
if s.AlreadyCompleted.Set {
e.FieldStart("already_completed")
s.AlreadyCompleted.Encode(e)
}
}
{
if s.PlanID.Set {
e.FieldStart("plan_id")
s.PlanID.Encode(e)
}
}
{
if s.Error.Set {
e.FieldStart("error")
s.Error.Encode(e)
}
}
{
if s.Message.Set {
e.FieldStart("message")
s.Message.Encode(e)
}
}
}
var jsonFieldsNameOfOnboardingResult = [5]string{
0: "success",
1: "already_completed",
2: "plan_id",
3: "error",
4: "message",
}
// Decode decodes OnboardingResult from json.
func (s *OnboardingResult) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode OnboardingResult to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "success":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Bool()
s.Success = bool(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"success\"")
}
case "already_completed":
if err := func() error {
s.AlreadyCompleted.Reset()
if err := s.AlreadyCompleted.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"already_completed\"")
}
case "plan_id":
if err := func() error {
s.PlanID.Reset()
if err := s.PlanID.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"plan_id\"")
}
case "error":
if err := func() error {
s.Error.Reset()
if err := s.Error.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"error\"")
}
case "message":
if err := func() error {
s.Message.Reset()
if err := s.Message.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"message\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode OnboardingResult")
}
// 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(jsonFieldsNameOfOnboardingResult) {
name = jsonFieldsNameOfOnboardingResult[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 *OnboardingResult) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OnboardingResult) 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 time.Time as json.
func (o OptDateTime) Encode(e *jx.Encoder, format func(*jx.Encoder, time.Time)) {
if !o.Set {
return
}
format(e, o.Value)
}
// Decode decodes time.Time from json.
func (o *OptDateTime) Decode(d *jx.Decoder, format func(*jx.Decoder) (time.Time, error)) error {
if o == nil {
return errors.New("invalid: unable to decode OptDateTime to nil")
}
o.Set = true
v, err := format(d)
if err != nil {
return err
}
o.Value = v
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptDateTime) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e, json.EncodeDateTime)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptDateTime) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d, json.DecodeDateTime)
}
// Encode encodes int as json.
func (o OptInt) Encode(e *jx.Encoder) {
if !o.Set {
return
}
e.Int(int(o.Value))
}
// Decode decodes int from json.
func (o *OptInt) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptInt to nil")
}
o.Set = true
v, err := d.Int()
if err != nil {
return err
}
o.Value = int(v)
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptInt) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptInt) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes ModuleWithToolsDescriptions as json.
func (o OptModuleWithToolsDescriptions) Encode(e *jx.Encoder) {
if !o.Set {
return
}
o.Value.Encode(e)
}
// Decode decodes ModuleWithToolsDescriptions from json.
func (o *OptModuleWithToolsDescriptions) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptModuleWithToolsDescriptions to nil")
}
o.Set = true
o.Value = make(ModuleWithToolsDescriptions)
if err := o.Value.Decode(d); err != nil {
return err
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptModuleWithToolsDescriptions) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptModuleWithToolsDescriptions) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes time.Time as json.
func (o OptNilDateTime) Encode(e *jx.Encoder, format func(*jx.Encoder, time.Time)) {
if !o.Set {
return
}
if o.Null {
e.Null()
return
}
format(e, o.Value)
}
// Decode decodes time.Time from json.
func (o *OptNilDateTime) Decode(d *jx.Decoder, format func(*jx.Decoder) (time.Time, error)) error {
if o == nil {
return errors.New("invalid: unable to decode OptNilDateTime to nil")
}
if d.Next() == jx.Null {
if err := d.Null(); err != nil {
return err
}
var v time.Time
o.Value = v
o.Set = true
o.Null = true
return nil
}
o.Set = true
o.Null = false
v, err := format(d)
if err != nil {
return err
}
o.Value = v
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptNilDateTime) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e, json.EncodeDateTime)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptNilDateTime) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d, json.DecodeDateTime)
}
// 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 PlanInfoFeatures as json.
func (o OptPlanInfoFeatures) Encode(e *jx.Encoder) {
if !o.Set {
return
}
o.Value.Encode(e)
}
// Decode decodes PlanInfoFeatures from json.
func (o *OptPlanInfoFeatures) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptPlanInfoFeatures to nil")
}
o.Set = true
o.Value = make(PlanInfoFeatures)
if err := o.Value.Decode(d); err != nil {
return err
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptPlanInfoFeatures) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptPlanInfoFeatures) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes string as json.
func (o OptString) Encode(e *jx.Encoder) {
if !o.Set {
return
}
e.Str(string(o.Value))
}
// Decode decodes string from json.
func (o *OptString) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptString to nil")
}
o.Set = true
v, err := d.Str()
if err != nil {
return err
}
o.Value = string(v)
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptString) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptString) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *PlanInfo) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *PlanInfo) encodeFields(e *jx.Encoder) {
{
e.FieldStart("id")
e.Str(s.ID)
}
{
e.FieldStart("name")
e.Str(s.Name)
}
{
e.FieldStart("daily_limit")
e.Int(s.DailyLimit)
}
{
e.FieldStart("price_monthly")
e.Int(s.PriceMonthly)
}
{
if s.StripePriceID.Set {
e.FieldStart("stripe_price_id")
s.StripePriceID.Encode(e)
}
}
{
if s.Features.Set {
e.FieldStart("features")
s.Features.Encode(e)
}
}
}
var jsonFieldsNameOfPlanInfo = [6]string{
0: "id",
1: "name",
2: "daily_limit",
3: "price_monthly",
4: "stripe_price_id",
5: "features",
}
// Decode decodes PlanInfo from json.
func (s *PlanInfo) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode PlanInfo to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "id":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Str()
s.ID = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"id\"")
}
case "name":
requiredBitSet[0] |= 1 << 1
if err := func() error {
v, err := d.Str()
s.Name = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"name\"")
}
case "daily_limit":
requiredBitSet[0] |= 1 << 2
if err := func() error {
v, err := d.Int()
s.DailyLimit = int(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"daily_limit\"")
}
case "price_monthly":
requiredBitSet[0] |= 1 << 3
if err := func() error {
v, err := d.Int()
s.PriceMonthly = int(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"price_monthly\"")
}
case "stripe_price_id":
if err := func() error {
s.StripePriceID.Reset()
if err := s.StripePriceID.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"stripe_price_id\"")
}
case "features":
if err := func() error {
s.Features.Reset()
if err := s.Features.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"features\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode PlanInfo")
}
// Validate required fields.
var failures []validate.FieldError
for i, mask := range [1]uint8{
0b00001111,
} {
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(jsonFieldsNameOfPlanInfo) {
name = jsonFieldsNameOfPlanInfo[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 *PlanInfo) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PlanInfo) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s PlanInfoFeatures) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields implements json.Marshaler.
func (s PlanInfoFeatures) encodeFields(e *jx.Encoder) {
for k, elem := range s {
e.FieldStart(k)
if len(elem) != 0 {
e.Raw(elem)
}
}
}
// Decode decodes PlanInfoFeatures from json.
func (s *PlanInfoFeatures) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode PlanInfoFeatures to nil")
}
m := s.init()
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
var elem jx.Raw
if err := func() error {
v, err := d.RawAppend(nil)
elem = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrapf(err, "decode field %q", k)
}
m[string(k)] = elem
return nil
}); err != nil {
return errors.Wrap(err, "decode PlanInfoFeatures")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s PlanInfoFeatures) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PlanInfoFeatures) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *Prompt) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *Prompt) encodeFields(e *jx.Encoder) {
{
e.FieldStart("id")
e.Str(s.ID)
}
{
if s.ModuleName.Set {
e.FieldStart("module_name")
s.ModuleName.Encode(e)
}
}
{
e.FieldStart("name")
e.Str(s.Name)
}
{
if s.Description.Set {
e.FieldStart("description")
s.Description.Encode(e)
}
}
{
e.FieldStart("content")
e.Str(s.Content)
}
{
e.FieldStart("enabled")
e.Bool(s.Enabled)
}
{
e.FieldStart("created_at")
json.EncodeDateTime(e, s.CreatedAt)
}
{
e.FieldStart("updated_at")
json.EncodeDateTime(e, s.UpdatedAt)
}
}
var jsonFieldsNameOfPrompt = [8]string{
0: "id",
1: "module_name",
2: "name",
3: "description",
4: "content",
5: "enabled",
6: "created_at",
7: "updated_at",
}
// Decode decodes Prompt from json.
func (s *Prompt) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode Prompt to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "id":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Str()
s.ID = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"id\"")
}
case "module_name":
if err := func() error {
s.ModuleName.Reset()
if err := s.ModuleName.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"module_name\"")
}
case "name":
requiredBitSet[0] |= 1 << 2
if err := func() error {
v, err := d.Str()
s.Name = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"name\"")
}
case "description":
if err := func() error {
s.Description.Reset()
if err := s.Description.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"description\"")
}
case "content":
requiredBitSet[0] |= 1 << 4
if err := func() error {
v, err := d.Str()
s.Content = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"content\"")
}
case "enabled":
requiredBitSet[0] |= 1 << 5
if err := func() error {
v, err := d.Bool()
s.Enabled = bool(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"enabled\"")
}
case "created_at":
requiredBitSet[0] |= 1 << 6
if err := func() error {
v, err := json.DecodeDateTime(d)
s.CreatedAt = v
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"created_at\"")
}
case "updated_at":
requiredBitSet[0] |= 1 << 7
if err := func() error {
v, err := json.DecodeDateTime(d)
s.UpdatedAt = v
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"updated_at\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode Prompt")
}
// Validate required fields.
var failures []validate.FieldError
for i, mask := range [1]uint8{
0b11110101,
} {
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(jsonFieldsNameOfPrompt) {
name = jsonFieldsNameOfPrompt[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 *Prompt) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Prompt) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *RegisterResult) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *RegisterResult) encodeFields(e *jx.Encoder) {
{
e.FieldStart("id")
e.Str(s.ID)
}
}
var jsonFieldsNameOfRegisterResult = [1]string{
0: "id",
}
// Decode decodes RegisterResult from json.
func (s *RegisterResult) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode RegisterResult to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "id":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Str()
s.ID = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"id\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode RegisterResult")
}
// 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(jsonFieldsNameOfRegisterResult) {
name = jsonFieldsNameOfRegisterResult[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 *RegisterResult) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RegisterResult) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *RevokeConsentResult) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *RevokeConsentResult) encodeFields(e *jx.Encoder) {
{
if s.Revoked.Set {
e.FieldStart("revoked")
s.Revoked.Encode(e)
}
}
}
var jsonFieldsNameOfRevokeConsentResult = [1]string{
0: "revoked",
}
// Decode decodes RevokeConsentResult from json.
func (s *RevokeConsentResult) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode RevokeConsentResult to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "revoked":
if err := func() error {
s.Revoked.Reset()
if err := s.Revoked.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"revoked\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode RevokeConsentResult")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *RevokeConsentResult) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RevokeConsentResult) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *StripeCustomer) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *StripeCustomer) encodeFields(e *jx.Encoder) {
{
if s.StripeCustomerID.Set {
e.FieldStart("stripe_customer_id")
s.StripeCustomerID.Encode(e)
}
}
}
var jsonFieldsNameOfStripeCustomer = [1]string{
0: "stripe_customer_id",
}
// Decode decodes StripeCustomer from json.
func (s *StripeCustomer) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode StripeCustomer to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "stripe_customer_id":
if err := func() error {
s.StripeCustomerID.Reset()
if err := s.StripeCustomerID.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"stripe_customer_id\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode StripeCustomer")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *StripeCustomer) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *StripeCustomer) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *SuccessResult) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *SuccessResult) encodeFields(e *jx.Encoder) {
{
e.FieldStart("success")
e.Bool(s.Success)
}
}
var jsonFieldsNameOfSuccessResult = [1]string{
0: "success",
}
// Decode decodes SuccessResult from json.
func (s *SuccessResult) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode SuccessResult to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "success":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Bool()
s.Success = bool(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"success\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode SuccessResult")
}
// 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(jsonFieldsNameOfSuccessResult) {
name = jsonFieldsNameOfSuccessResult[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 *SuccessResult) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SuccessResult) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *UpdatePromptBody) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *UpdatePromptBody) encodeFields(e *jx.Encoder) {
{
e.FieldStart("name")
e.Str(s.Name)
}
{
e.FieldStart("content")
e.Str(s.Content)
}
{
if s.ModuleName.Set {
e.FieldStart("module_name")
s.ModuleName.Encode(e)
}
}
{
e.FieldStart("enabled")
e.Bool(s.Enabled)
}
{
if s.Description.Set {
e.FieldStart("description")
s.Description.Encode(e)
}
}
}
var jsonFieldsNameOfUpdatePromptBody = [5]string{
0: "name",
1: "content",
2: "module_name",
3: "enabled",
4: "description",
}
// Decode decodes UpdatePromptBody from json.
func (s *UpdatePromptBody) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode UpdatePromptBody to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "name":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Str()
s.Name = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"name\"")
}
case "content":
requiredBitSet[0] |= 1 << 1
if err := func() error {
v, err := d.Str()
s.Content = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"content\"")
}
case "module_name":
if err := func() error {
s.ModuleName.Reset()
if err := s.ModuleName.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"module_name\"")
}
case "enabled":
requiredBitSet[0] |= 1 << 3
if err := func() error {
v, err := d.Bool()
s.Enabled = bool(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"enabled\"")
}
case "description":
if err := func() error {
s.Description.Reset()
if err := s.Description.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"description\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode UpdatePromptBody")
}
// Validate required fields.
var failures []validate.FieldError
for i, mask := range [1]uint8{
0b00001011,
} {
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(jsonFieldsNameOfUpdatePromptBody) {
name = jsonFieldsNameOfUpdatePromptBody[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 *UpdatePromptBody) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UpdatePromptBody) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *UpdateSettingsBody) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *UpdateSettingsBody) encodeFields(e *jx.Encoder) {
{
if len(s.Settings) != 0 {
e.FieldStart("settings")
e.Raw(s.Settings)
}
}
}
var jsonFieldsNameOfUpdateSettingsBody = [1]string{
0: "settings",
}
// Decode decodes UpdateSettingsBody from json.
func (s *UpdateSettingsBody) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode UpdateSettingsBody to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "settings":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.RawAppend(nil)
s.Settings = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"settings\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode UpdateSettingsBody")
}
// 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(jsonFieldsNameOfUpdateSettingsBody) {
name = jsonFieldsNameOfUpdateSettingsBody[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 *UpdateSettingsBody) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UpdateSettingsBody) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *UpsertCredentialBody) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *UpsertCredentialBody) encodeFields(e *jx.Encoder) {
{
if len(s.Credentials) != 0 {
e.FieldStart("credentials")
e.Raw(s.Credentials)
}
}
}
var jsonFieldsNameOfUpsertCredentialBody = [1]string{
0: "credentials",
}
// Decode decodes UpsertCredentialBody from json.
func (s *UpsertCredentialBody) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode UpsertCredentialBody to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "credentials":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.RawAppend(nil)
s.Credentials = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"credentials\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode UpsertCredentialBody")
}
// 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(jsonFieldsNameOfUpsertCredentialBody) {
name = jsonFieldsNameOfUpsertCredentialBody[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 *UpsertCredentialBody) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UpsertCredentialBody) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *UpsertCredentialResult) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *UpsertCredentialResult) encodeFields(e *jx.Encoder) {
{
e.FieldStart("success")
e.Bool(s.Success)
}
{
e.FieldStart("module")
e.Str(s.Module)
}
}
var jsonFieldsNameOfUpsertCredentialResult = [2]string{
0: "success",
1: "module",
}
// Decode decodes UpsertCredentialResult from json.
func (s *UpsertCredentialResult) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode UpsertCredentialResult to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "success":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Bool()
s.Success = bool(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"success\"")
}
case "module":
requiredBitSet[0] |= 1 << 1
if err := func() error {
v, err := d.Str()
s.Module = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"module\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode UpsertCredentialResult")
}
// Validate required fields.
var failures []validate.FieldError
for i, mask := range [1]uint8{
0b00000011,
} {
if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
// Mask only required fields and check equality to mask using XOR.
//
// If XOR result is not zero, result is not equal to expected, so some fields are missed.
// Bits of fields which would be set are actually bits of missed fields.
missed := bits.OnesCount8(result)
for bitN := 0; bitN < missed; bitN++ {
bitIdx := bits.TrailingZeros8(result)
fieldIdx := i*8 + bitIdx
var name string
if fieldIdx < len(jsonFieldsNameOfUpsertCredentialResult) {
name = jsonFieldsNameOfUpsertCredentialResult[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 *UpsertCredentialResult) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UpsertCredentialResult) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *UpsertModuleDescriptionBody) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *UpsertModuleDescriptionBody) encodeFields(e *jx.Encoder) {
{
e.FieldStart("description")
e.Str(s.Description)
}
}
var jsonFieldsNameOfUpsertModuleDescriptionBody = [1]string{
0: "description",
}
// Decode decodes UpsertModuleDescriptionBody from json.
func (s *UpsertModuleDescriptionBody) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode UpsertModuleDescriptionBody to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "description":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Str()
s.Description = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"description\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode UpsertModuleDescriptionBody")
}
// 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(jsonFieldsNameOfUpsertModuleDescriptionBody) {
name = jsonFieldsNameOfUpsertModuleDescriptionBody[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 *UpsertModuleDescriptionBody) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UpsertModuleDescriptionBody) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *UpsertOAuthAppBody) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *UpsertOAuthAppBody) encodeFields(e *jx.Encoder) {
{
e.FieldStart("client_id")
e.Str(s.ClientID)
}
{
e.FieldStart("client_secret")
e.Str(s.ClientSecret)
}
{
e.FieldStart("redirect_uri")
e.Str(s.RedirectURI)
}
{
e.FieldStart("enabled")
e.Bool(s.Enabled)
}
}
var jsonFieldsNameOfUpsertOAuthAppBody = [4]string{
0: "client_id",
1: "client_secret",
2: "redirect_uri",
3: "enabled",
}
// Decode decodes UpsertOAuthAppBody from json.
func (s *UpsertOAuthAppBody) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode UpsertOAuthAppBody to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "client_id":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Str()
s.ClientID = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"client_id\"")
}
case "client_secret":
requiredBitSet[0] |= 1 << 1
if err := func() error {
v, err := d.Str()
s.ClientSecret = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"client_secret\"")
}
case "redirect_uri":
requiredBitSet[0] |= 1 << 2
if err := func() error {
v, err := d.Str()
s.RedirectURI = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"redirect_uri\"")
}
case "enabled":
requiredBitSet[0] |= 1 << 3
if err := func() error {
v, err := d.Bool()
s.Enabled = bool(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"enabled\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode UpsertOAuthAppBody")
}
// Validate required fields.
var failures []validate.FieldError
for i, mask := range [1]uint8{
0b00001111,
} {
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(jsonFieldsNameOfUpsertOAuthAppBody) {
name = jsonFieldsNameOfUpsertOAuthAppBody[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 *UpsertOAuthAppBody) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UpsertOAuthAppBody) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *UpsertPromptResult) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *UpsertPromptResult) encodeFields(e *jx.Encoder) {
{
e.FieldStart("success")
e.Bool(s.Success)
}
{
if s.ID.Set {
e.FieldStart("id")
s.ID.Encode(e)
}
}
{
if s.Action.Set {
e.FieldStart("action")
s.Action.Encode(e)
}
}
{
if s.Error.Set {
e.FieldStart("error")
s.Error.Encode(e)
}
}
}
var jsonFieldsNameOfUpsertPromptResult = [4]string{
0: "success",
1: "id",
2: "action",
3: "error",
}
// Decode decodes UpsertPromptResult from json.
func (s *UpsertPromptResult) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode UpsertPromptResult to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "success":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Bool()
s.Success = bool(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"success\"")
}
case "id":
if err := func() error {
s.ID.Reset()
if err := s.ID.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"id\"")
}
case "action":
if err := func() error {
s.Action.Reset()
if err := s.Action.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"action\"")
}
case "error":
if err := func() error {
s.Error.Reset()
if err := s.Error.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"error\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode UpsertPromptResult")
}
// 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(jsonFieldsNameOfUpsertPromptResult) {
name = jsonFieldsNameOfUpsertPromptResult[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 *UpsertPromptResult) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UpsertPromptResult) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *UpsertToolSettingsBody) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *UpsertToolSettingsBody) encodeFields(e *jx.Encoder) {
{
e.FieldStart("enabled_tools")
e.ArrStart()
for _, elem := range s.EnabledTools {
e.Str(elem)
}
e.ArrEnd()
}
{
e.FieldStart("disabled_tools")
e.ArrStart()
for _, elem := range s.DisabledTools {
e.Str(elem)
}
e.ArrEnd()
}
}
var jsonFieldsNameOfUpsertToolSettingsBody = [2]string{
0: "enabled_tools",
1: "disabled_tools",
}
// Decode decodes UpsertToolSettingsBody from json.
func (s *UpsertToolSettingsBody) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode UpsertToolSettingsBody to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "enabled_tools":
requiredBitSet[0] |= 1 << 0
if err := func() error {
s.EnabledTools = 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.EnabledTools = append(s.EnabledTools, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"enabled_tools\"")
}
case "disabled_tools":
requiredBitSet[0] |= 1 << 1
if err := func() error {
s.DisabledTools = 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.DisabledTools = append(s.DisabledTools, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"disabled_tools\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode UpsertToolSettingsBody")
}
// Validate required fields.
var failures []validate.FieldError
for i, mask := range [1]uint8{
0b00000011,
} {
if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
// Mask only required fields and check equality to mask using XOR.
//
// If XOR result is not zero, result is not equal to expected, so some fields are missed.
// Bits of fields which would be set are actually bits of missed fields.
missed := bits.OnesCount8(result)
for bitN := 0; bitN < missed; bitN++ {
bitIdx := bits.TrailingZeros8(result)
fieldIdx := i*8 + bitIdx
var name string
if fieldIdx < len(jsonFieldsNameOfUpsertToolSettingsBody) {
name = jsonFieldsNameOfUpsertToolSettingsBody[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 *UpsertToolSettingsBody) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UpsertToolSettingsBody) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *UpsertToolSettingsResult) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *UpsertToolSettingsResult) encodeFields(e *jx.Encoder) {
{
e.FieldStart("success")
e.Bool(s.Success)
}
{
if s.EnabledCount.Set {
e.FieldStart("enabled_count")
s.EnabledCount.Encode(e)
}
}
{
if s.DisabledCount.Set {
e.FieldStart("disabled_count")
s.DisabledCount.Encode(e)
}
}
}
var jsonFieldsNameOfUpsertToolSettingsResult = [3]string{
0: "success",
1: "enabled_count",
2: "disabled_count",
}
// Decode decodes UpsertToolSettingsResult from json.
func (s *UpsertToolSettingsResult) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode UpsertToolSettingsResult to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "success":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Bool()
s.Success = bool(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"success\"")
}
case "enabled_count":
if err := func() error {
s.EnabledCount.Reset()
if err := s.EnabledCount.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"enabled_count\"")
}
case "disabled_count":
if err := func() error {
s.DisabledCount.Reset()
if err := s.DisabledCount.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"disabled_count\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode UpsertToolSettingsResult")
}
// 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(jsonFieldsNameOfUpsertToolSettingsResult) {
name = jsonFieldsNameOfUpsertToolSettingsResult[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 *UpsertToolSettingsResult) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UpsertToolSettingsResult) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *UsageData) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *UsageData) encodeFields(e *jx.Encoder) {
{
e.FieldStart("total_used")
e.Int(s.TotalUsed)
}
{
e.FieldStart("by_module")
s.ByModule.Encode(e)
}
{
e.FieldStart("period")
s.Period.Encode(e)
}
}
var jsonFieldsNameOfUsageData = [3]string{
0: "total_used",
1: "by_module",
2: "period",
}
// Decode decodes UsageData from json.
func (s *UsageData) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode UsageData to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "total_used":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Int()
s.TotalUsed = int(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"total_used\"")
}
case "by_module":
requiredBitSet[0] |= 1 << 1
if err := func() error {
if err := s.ByModule.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"by_module\"")
}
case "period":
requiredBitSet[0] |= 1 << 2
if err := func() error {
if err := s.Period.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"period\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode UsageData")
}
// Validate required fields.
var failures []validate.FieldError
for i, mask := range [1]uint8{
0b00000111,
} {
if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
// Mask only required fields and check equality to mask using XOR.
//
// If XOR result is not zero, result is not equal to expected, so some fields are missed.
// Bits of fields which would be set are actually bits of missed fields.
missed := bits.OnesCount8(result)
for bitN := 0; bitN < missed; bitN++ {
bitIdx := bits.TrailingZeros8(result)
fieldIdx := i*8 + bitIdx
var name string
if fieldIdx < len(jsonFieldsNameOfUsageData) {
name = jsonFieldsNameOfUsageData[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 *UsageData) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UsageData) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s UsageDataByModule) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields implements json.Marshaler.
func (s UsageDataByModule) encodeFields(e *jx.Encoder) {
for k, elem := range s {
e.FieldStart(k)
e.Int(elem)
}
}
// Decode decodes UsageDataByModule from json.
func (s *UsageDataByModule) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode UsageDataByModule to nil")
}
m := s.init()
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
var elem int
if err := func() error {
v, err := d.Int()
elem = int(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrapf(err, "decode field %q", k)
}
m[string(k)] = elem
return nil
}); err != nil {
return errors.Wrap(err, "decode UsageDataByModule")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s UsageDataByModule) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UsageDataByModule) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *UsagePeriod) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *UsagePeriod) encodeFields(e *jx.Encoder) {
{
e.FieldStart("start")
e.Str(s.Start)
}
{
e.FieldStart("end")
e.Str(s.End)
}
}
var jsonFieldsNameOfUsagePeriod = [2]string{
0: "start",
1: "end",
}
// Decode decodes UsagePeriod from json.
func (s *UsagePeriod) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode UsagePeriod to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "start":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Str()
s.Start = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"start\"")
}
case "end":
requiredBitSet[0] |= 1 << 1
if err := func() error {
v, err := d.Str()
s.End = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"end\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode UsagePeriod")
}
// Validate required fields.
var failures []validate.FieldError
for i, mask := range [1]uint8{
0b00000011,
} {
if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
// Mask only required fields and check equality to mask using XOR.
//
// If XOR result is not zero, result is not equal to expected, so some fields are missed.
// Bits of fields which would be set are actually bits of missed fields.
missed := bits.OnesCount8(result)
for bitN := 0; bitN < missed; bitN++ {
bitIdx := bits.TrailingZeros8(result)
fieldIdx := i*8 + bitIdx
var name string
if fieldIdx < len(jsonFieldsNameOfUsagePeriod) {
name = jsonFieldsNameOfUsagePeriod[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 *UsagePeriod) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UsagePeriod) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *UserProfile) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *UserProfile) encodeFields(e *jx.Encoder) {
{
e.FieldStart("user_id")
e.Str(s.UserID)
}
{
e.FieldStart("email")
e.Str(s.Email)
}
{
e.FieldStart("account_status")
e.Str(s.AccountStatus)
}
{
e.FieldStart("plan_id")
e.Str(s.PlanID)
}
{
e.FieldStart("daily_used")
e.Int(s.DailyUsed)
}
{
e.FieldStart("daily_limit")
e.Int(s.DailyLimit)
}
{
e.FieldStart("role")
e.Str(s.Role)
}
{
if len(s.Settings) != 0 {
e.FieldStart("settings")
e.Raw(s.Settings)
}
}
{
if s.DisplayName.Set {
e.FieldStart("display_name")
s.DisplayName.Encode(e)
}
}
{
e.FieldStart("connected_count")
e.Int(s.ConnectedCount)
}
}
var jsonFieldsNameOfUserProfile = [10]string{
0: "user_id",
1: "email",
2: "account_status",
3: "plan_id",
4: "daily_used",
5: "daily_limit",
6: "role",
7: "settings",
8: "display_name",
9: "connected_count",
}
// Decode decodes UserProfile from json.
func (s *UserProfile) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode UserProfile to nil")
}
var requiredBitSet [2]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "user_id":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Str()
s.UserID = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"user_id\"")
}
case "email":
requiredBitSet[0] |= 1 << 1
if err := func() error {
v, err := d.Str()
s.Email = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"email\"")
}
case "account_status":
requiredBitSet[0] |= 1 << 2
if err := func() error {
v, err := d.Str()
s.AccountStatus = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"account_status\"")
}
case "plan_id":
requiredBitSet[0] |= 1 << 3
if err := func() error {
v, err := d.Str()
s.PlanID = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"plan_id\"")
}
case "daily_used":
requiredBitSet[0] |= 1 << 4
if err := func() error {
v, err := d.Int()
s.DailyUsed = int(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"daily_used\"")
}
case "daily_limit":
requiredBitSet[0] |= 1 << 5
if err := func() error {
v, err := d.Int()
s.DailyLimit = int(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"daily_limit\"")
}
case "role":
requiredBitSet[0] |= 1 << 6
if err := func() error {
v, err := d.Str()
s.Role = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"role\"")
}
case "settings":
if err := func() error {
v, err := d.RawAppend(nil)
s.Settings = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"settings\"")
}
case "display_name":
if err := func() error {
s.DisplayName.Reset()
if err := s.DisplayName.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"display_name\"")
}
case "connected_count":
requiredBitSet[1] |= 1 << 1
if err := func() error {
v, err := d.Int()
s.ConnectedCount = int(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"connected_count\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode UserProfile")
}
// Validate required fields.
var failures []validate.FieldError
for i, mask := range [2]uint8{
0b01111111,
0b00000010,
} {
if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
// Mask only required fields and check equality to mask using XOR.
//
// If XOR result is not zero, result is not equal to expected, so some fields are missed.
// Bits of fields which would be set are actually bits of missed fields.
missed := bits.OnesCount8(result)
for bitN := 0; bitN < missed; bitN++ {
bitIdx := bits.TrailingZeros8(result)
fieldIdx := i*8 + bitIdx
var name string
if fieldIdx < len(jsonFieldsNameOfUserProfile) {
name = jsonFieldsNameOfUserProfile[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 *UserProfile) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UserProfile) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
