oas_uri_gen.go

// Code generated by ogen, DO NOT EDIT.

package api

import (
	"time"

	"github.com/go-faster/errors"

	"github.com/ogen-go/ogen/conv"
	"github.com/ogen-go/ogen/uri"
)

// EncodeURI encodes ContainersListServersPage as URI form.
func (s *ContainersListServersPage) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("number", func(e uri.Encoder) error {
		if val, ok := s.Number.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"number\"")
	}
	if err := e.EncodeField("size", func(e uri.Encoder) error {
		if val, ok := s.Size.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"size\"")
	}
	return nil
}

var uriFieldsNameOfContainersListServersPage = [2]string{
	0: "number",
	1: "size",
}

// DecodeURI decodes ContainersListServersPage from URI form.
func (s *ContainersListServersPage) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ContainersListServersPage to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "number":
			if err := func() error {
				var sDotNumberVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotNumberVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Number.SetTo(sDotNumberVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"number\"")
			}
		case "size":
			if err := func() error {
				var sDotSizeVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotSizeVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Size.SetTo(sDotSizeVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"size\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode ContainersListServersPage")
	}

	return nil
}

// EncodeURI encodes DNSTLSAttemptsFilter as URI form.
func (s *DNSTLSAttemptsFilter) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("domain", func(e uri.Encoder) error {
		if val, ok := s.Domain.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"domain\"")
	}
	return nil
}

var uriFieldsNameOfDNSTLSAttemptsFilter = [1]string{
	0: "domain",
}

// DecodeURI decodes DNSTLSAttemptsFilter from URI form.
func (s *DNSTLSAttemptsFilter) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode DNSTLSAttemptsFilter to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "domain":
			if err := func() error {
				var sDotDomainVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotDomainVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Domain.SetTo(sDotDomainVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"domain\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode DNSTLSAttemptsFilter")
	}

	return nil
}

// EncodeURI encodes DNSTLSAttemptsPage as URI form.
func (s *DNSTLSAttemptsPage) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("number", func(e uri.Encoder) error {
		if val, ok := s.Number.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"number\"")
	}
	if err := e.EncodeField("size", func(e uri.Encoder) error {
		if val, ok := s.Size.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"size\"")
	}
	return nil
}

var uriFieldsNameOfDNSTLSAttemptsPage = [2]string{
	0: "number",
	1: "size",
}

// DecodeURI decodes DNSTLSAttemptsPage from URI form.
func (s *DNSTLSAttemptsPage) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode DNSTLSAttemptsPage to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "number":
			if err := func() error {
				var sDotNumberVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotNumberVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Number.SetTo(sDotNumberVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"number\"")
			}
		case "size":
			if err := func() error {
				var sDotSizeVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotSizeVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Size.SetTo(sDotSizeVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"size\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode DNSTLSAttemptsPage")
	}

	return nil
}

// EncodeURI encodes GetAccountInvitesFilter as URI form.
func (s *GetAccountInvitesFilter) EncodeURI(e uri.Encoder) error {
	return nil
}

var uriFieldsNameOfGetAccountInvitesFilter = [0]string{}

// DecodeURI decodes GetAccountInvitesFilter from URI form.
func (s *GetAccountInvitesFilter) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetAccountInvitesFilter to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetAccountInvitesFilter")
	}

	return nil
}

// EncodeURI encodes GetAccountInvitesPage as URI form.
func (s *GetAccountInvitesPage) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("number", func(e uri.Encoder) error {
		if val, ok := s.Number.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"number\"")
	}
	if err := e.EncodeField("size", func(e uri.Encoder) error {
		if val, ok := s.Size.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"size\"")
	}
	return nil
}

var uriFieldsNameOfGetAccountInvitesPage = [2]string{
	0: "number",
	1: "size",
}

// DecodeURI decodes GetAccountInvitesPage from URI form.
func (s *GetAccountInvitesPage) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetAccountInvitesPage to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "number":
			if err := func() error {
				var sDotNumberVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotNumberVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Number.SetTo(sDotNumberVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"number\"")
			}
		case "size":
			if err := func() error {
				var sDotSizeVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotSizeVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Size.SetTo(sDotSizeVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"size\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetAccountInvitesPage")
	}

	return nil
}

// EncodeURI encodes GetAccountLoginsFilter as URI form.
func (s *GetAccountLoginsFilter) EncodeURI(e uri.Encoder) error {
	return nil
}

var uriFieldsNameOfGetAccountLoginsFilter = [0]string{}

// DecodeURI decodes GetAccountLoginsFilter from URI form.
func (s *GetAccountLoginsFilter) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetAccountLoginsFilter to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetAccountLoginsFilter")
	}

	return nil
}

// EncodeURI encodes GetAccountLoginsPage as URI form.
func (s *GetAccountLoginsPage) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("number", func(e uri.Encoder) error {
		if val, ok := s.Number.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"number\"")
	}
	if err := e.EncodeField("size", func(e uri.Encoder) error {
		if val, ok := s.Size.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"size\"")
	}
	return nil
}

var uriFieldsNameOfGetAccountLoginsPage = [2]string{
	0: "number",
	1: "size",
}

// DecodeURI decodes GetAccountLoginsPage from URI form.
func (s *GetAccountLoginsPage) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetAccountLoginsPage to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "number":
			if err := func() error {
				var sDotNumberVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotNumberVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Number.SetTo(sDotNumberVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"number\"")
			}
		case "size":
			if err := func() error {
				var sDotSizeVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotSizeVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Size.SetTo(sDotSizeVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"size\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetAccountLoginsPage")
	}

	return nil
}

// EncodeURI encodes GetAnnouncementsListFilter as URI form.
func (s *GetAnnouncementsListFilter) EncodeURI(e uri.Encoder) error {
	return nil
}

var uriFieldsNameOfGetAnnouncementsListFilter = [0]string{}

// DecodeURI decodes GetAnnouncementsListFilter from URI form.
func (s *GetAnnouncementsListFilter) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetAnnouncementsListFilter to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetAnnouncementsListFilter")
	}

	return nil
}

// EncodeURI encodes GetAnnouncementsListPage as URI form.
func (s *GetAnnouncementsListPage) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("number", func(e uri.Encoder) error {
		if val, ok := s.Number.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"number\"")
	}
	if err := e.EncodeField("size", func(e uri.Encoder) error {
		if val, ok := s.Size.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"size\"")
	}
	return nil
}

var uriFieldsNameOfGetAnnouncementsListPage = [2]string{
	0: "number",
	1: "size",
}

// DecodeURI decodes GetAnnouncementsListPage from URI form.
func (s *GetAnnouncementsListPage) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetAnnouncementsListPage to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "number":
			if err := func() error {
				var sDotNumberVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotNumberVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Number.SetTo(sDotNumberVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"number\"")
			}
		case "size":
			if err := func() error {
				var sDotSizeVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotSizeVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Size.SetTo(sDotSizeVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"size\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetAnnouncementsListPage")
	}

	return nil
}

// EncodeURI encodes GetApiKeysFilter as URI form.
func (s *GetApiKeysFilter) EncodeURI(e uri.Encoder) error {
	return nil
}

var uriFieldsNameOfGetApiKeysFilter = [0]string{}

// DecodeURI decodes GetApiKeysFilter from URI form.
func (s *GetApiKeysFilter) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetApiKeysFilter to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetApiKeysFilter")
	}

	return nil
}

// EncodeURI encodes GetApiKeysPage as URI form.
func (s *GetApiKeysPage) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("number", func(e uri.Encoder) error {
		if val, ok := s.Number.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"number\"")
	}
	if err := e.EncodeField("size", func(e uri.Encoder) error {
		if val, ok := s.Size.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"size\"")
	}
	return nil
}

var uriFieldsNameOfGetApiKeysPage = [2]string{
	0: "number",
	1: "size",
}

// DecodeURI decodes GetApiKeysPage from URI form.
func (s *GetApiKeysPage) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetApiKeysPage to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "number":
			if err := func() error {
				var sDotNumberVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotNumberVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Number.SetTo(sDotNumberVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"number\"")
			}
		case "size":
			if err := func() error {
				var sDotSizeVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotSizeVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Size.SetTo(sDotSizeVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"size\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetApiKeysPage")
	}

	return nil
}

// EncodeURI encodes GetAutoScaleGroupsFilter as URI form.
func (s *GetAutoScaleGroupsFilter) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("search", func(e uri.Encoder) error {
		if val, ok := s.Search.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"search\"")
	}
	if err := e.EncodeField("cluster", func(e uri.Encoder) error {
		if val, ok := s.Cluster.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"cluster\"")
	}
	if err := e.EncodeField("identifier", func(e uri.Encoder) error {
		if val, ok := s.Identifier.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"identifier\"")
	}
	if err := e.EncodeField("state", func(e uri.Encoder) error {
		if val, ok := s.State.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"state\"")
	}
	return nil
}

var uriFieldsNameOfGetAutoScaleGroupsFilter = [4]string{
	0: "search",
	1: "cluster",
	2: "identifier",
	3: "state",
}

// DecodeURI decodes GetAutoScaleGroupsFilter from URI form.
func (s *GetAutoScaleGroupsFilter) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetAutoScaleGroupsFilter to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "search":
			if err := func() error {
				var sDotSearchVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotSearchVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Search.SetTo(sDotSearchVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"search\"")
			}
		case "cluster":
			if err := func() error {
				var sDotClusterVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotClusterVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Cluster.SetTo(sDotClusterVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cluster\"")
			}
		case "identifier":
			if err := func() error {
				var sDotIdentifierVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotIdentifierVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Identifier.SetTo(sDotIdentifierVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"identifier\"")
			}
		case "state":
			if err := func() error {
				var sDotStateVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotStateVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.State.SetTo(sDotStateVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"state\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetAutoScaleGroupsFilter")
	}

	return nil
}

// EncodeURI encodes GetAutoScaleGroupsPage as URI form.
func (s *GetAutoScaleGroupsPage) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("number", func(e uri.Encoder) error {
		if val, ok := s.Number.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"number\"")
	}
	if err := e.EncodeField("size", func(e uri.Encoder) error {
		if val, ok := s.Size.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"size\"")
	}
	return nil
}

var uriFieldsNameOfGetAutoScaleGroupsPage = [2]string{
	0: "number",
	1: "size",
}

// DecodeURI decodes GetAutoScaleGroupsPage from URI form.
func (s *GetAutoScaleGroupsPage) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetAutoScaleGroupsPage to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "number":
			if err := func() error {
				var sDotNumberVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotNumberVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Number.SetTo(sDotNumberVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"number\"")
			}
		case "size":
			if err := func() error {
				var sDotSizeVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotSizeVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Size.SetTo(sDotSizeVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"size\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetAutoScaleGroupsPage")
	}

	return nil
}

// EncodeURI encodes GetBackupsCollectionPage as URI form.
func (s *GetBackupsCollectionPage) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("number", func(e uri.Encoder) error {
		if val, ok := s.Number.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"number\"")
	}
	if err := e.EncodeField("size", func(e uri.Encoder) error {
		if val, ok := s.Size.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"size\"")
	}
	return nil
}

var uriFieldsNameOfGetBackupsCollectionPage = [2]string{
	0: "number",
	1: "size",
}

// DecodeURI decodes GetBackupsCollectionPage from URI form.
func (s *GetBackupsCollectionPage) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetBackupsCollectionPage to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "number":
			if err := func() error {
				var sDotNumberVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotNumberVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Number.SetTo(sDotNumberVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"number\"")
			}
		case "size":
			if err := func() error {
				var sDotSizeVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotSizeVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Size.SetTo(sDotSizeVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"size\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetBackupsCollectionPage")
	}

	return nil
}

// EncodeURI encodes GetBillingMethodsFilter as URI form.
func (s *GetBillingMethodsFilter) EncodeURI(e uri.Encoder) error {
	return nil
}

var uriFieldsNameOfGetBillingMethodsFilter = [0]string{}

// DecodeURI decodes GetBillingMethodsFilter from URI form.
func (s *GetBillingMethodsFilter) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetBillingMethodsFilter to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetBillingMethodsFilter")
	}

	return nil
}

// EncodeURI encodes GetBillingMethodsPage as URI form.
func (s *GetBillingMethodsPage) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("number", func(e uri.Encoder) error {
		if val, ok := s.Number.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"number\"")
	}
	if err := e.EncodeField("size", func(e uri.Encoder) error {
		if val, ok := s.Size.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"size\"")
	}
	return nil
}

var uriFieldsNameOfGetBillingMethodsPage = [2]string{
	0: "number",
	1: "size",
}

// DecodeURI decodes GetBillingMethodsPage from URI form.
func (s *GetBillingMethodsPage) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetBillingMethodsPage to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "number":
			if err := func() error {
				var sDotNumberVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotNumberVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Number.SetTo(sDotNumberVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"number\"")
			}
		case "size":
			if err := func() error {
				var sDotSizeVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotSizeVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Size.SetTo(sDotSizeVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"size\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetBillingMethodsPage")
	}

	return nil
}

// EncodeURI encodes GetBillingOveragesFilter as URI form.
func (s *GetBillingOveragesFilter) EncodeURI(e uri.Encoder) error {
	return nil
}

var uriFieldsNameOfGetBillingOveragesFilter = [0]string{}

// DecodeURI decodes GetBillingOveragesFilter from URI form.
func (s *GetBillingOveragesFilter) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetBillingOveragesFilter to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetBillingOveragesFilter")
	}

	return nil
}

// EncodeURI encodes GetBillingOveragesPage as URI form.
func (s *GetBillingOveragesPage) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("number", func(e uri.Encoder) error {
		if val, ok := s.Number.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"number\"")
	}
	if err := e.EncodeField("size", func(e uri.Encoder) error {
		if val, ok := s.Size.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"size\"")
	}
	return nil
}

var uriFieldsNameOfGetBillingOveragesPage = [2]string{
	0: "number",
	1: "size",
}

// DecodeURI decodes GetBillingOveragesPage from URI form.
func (s *GetBillingOveragesPage) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetBillingOveragesPage to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "number":
			if err := func() error {
				var sDotNumberVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotNumberVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Number.SetTo(sDotNumberVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"number\"")
			}
		case "size":
			if err := func() error {
				var sDotSizeVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotSizeVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Size.SetTo(sDotSizeVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"size\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetBillingOveragesPage")
	}

	return nil
}

// EncodeURI encodes GetBillingServicesFilter as URI form.
func (s *GetBillingServicesFilter) EncodeURI(e uri.Encoder) error {
	return nil
}

var uriFieldsNameOfGetBillingServicesFilter = [0]string{}

// DecodeURI decodes GetBillingServicesFilter from URI form.
func (s *GetBillingServicesFilter) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetBillingServicesFilter to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetBillingServicesFilter")
	}

	return nil
}

// EncodeURI encodes GetBillingServicesPage as URI form.
func (s *GetBillingServicesPage) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("number", func(e uri.Encoder) error {
		if val, ok := s.Number.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"number\"")
	}
	if err := e.EncodeField("size", func(e uri.Encoder) error {
		if val, ok := s.Size.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"size\"")
	}
	return nil
}

var uriFieldsNameOfGetBillingServicesPage = [2]string{
	0: "number",
	1: "size",
}

// DecodeURI decodes GetBillingServicesPage from URI form.
func (s *GetBillingServicesPage) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetBillingServicesPage to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "number":
			if err := func() error {
				var sDotNumberVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotNumberVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Number.SetTo(sDotNumberVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"number\"")
			}
		case "size":
			if err := func() error {
				var sDotSizeVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotSizeVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Size.SetTo(sDotSizeVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"size\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetBillingServicesPage")
	}

	return nil
}

// EncodeURI encodes GetBillingSupportPlansFilter as URI form.
func (s *GetBillingSupportPlansFilter) EncodeURI(e uri.Encoder) error {
	return nil
}

var uriFieldsNameOfGetBillingSupportPlansFilter = [0]string{}

// DecodeURI decodes GetBillingSupportPlansFilter from URI form.
func (s *GetBillingSupportPlansFilter) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetBillingSupportPlansFilter to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetBillingSupportPlansFilter")
	}

	return nil
}

// EncodeURI encodes GetBillingSupportPlansPage as URI form.
func (s *GetBillingSupportPlansPage) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("number", func(e uri.Encoder) error {
		if val, ok := s.Number.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"number\"")
	}
	if err := e.EncodeField("size", func(e uri.Encoder) error {
		if val, ok := s.Size.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"size\"")
	}
	return nil
}

var uriFieldsNameOfGetBillingSupportPlansPage = [2]string{
	0: "number",
	1: "size",
}

// DecodeURI decodes GetBillingSupportPlansPage from URI form.
func (s *GetBillingSupportPlansPage) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetBillingSupportPlansPage to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "number":
			if err := func() error {
				var sDotNumberVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotNumberVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Number.SetTo(sDotNumberVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"number\"")
			}
		case "size":
			if err := func() error {
				var sDotSizeVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotSizeVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Size.SetTo(sDotSizeVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"size\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetBillingSupportPlansPage")
	}

	return nil
}

// EncodeURI encodes GetCompatibleImagesPage as URI form.
func (s *GetCompatibleImagesPage) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("number", func(e uri.Encoder) error {
		if val, ok := s.Number.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"number\"")
	}
	if err := e.EncodeField("size", func(e uri.Encoder) error {
		if val, ok := s.Size.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"size\"")
	}
	return nil
}

var uriFieldsNameOfGetCompatibleImagesPage = [2]string{
	0: "number",
	1: "size",
}

// DecodeURI decodes GetCompatibleImagesPage from URI form.
func (s *GetCompatibleImagesPage) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetCompatibleImagesPage to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "number":
			if err := func() error {
				var sDotNumberVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotNumberVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Number.SetTo(sDotNumberVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"number\"")
			}
		case "size":
			if err := func() error {
				var sDotSizeVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotSizeVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Size.SetTo(sDotSizeVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"size\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetCompatibleImagesPage")
	}

	return nil
}

// EncodeURI encodes GetContainerInstanceVolumesPage as URI form.
func (s *GetContainerInstanceVolumesPage) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("number", func(e uri.Encoder) error {
		if val, ok := s.Number.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"number\"")
	}
	if err := e.EncodeField("size", func(e uri.Encoder) error {
		if val, ok := s.Size.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"size\"")
	}
	return nil
}

var uriFieldsNameOfGetContainerInstanceVolumesPage = [2]string{
	0: "number",
	1: "size",
}

// DecodeURI decodes GetContainerInstanceVolumesPage from URI form.
func (s *GetContainerInstanceVolumesPage) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetContainerInstanceVolumesPage to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "number":
			if err := func() error {
				var sDotNumberVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotNumberVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Number.SetTo(sDotNumberVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"number\"")
			}
		case "size":
			if err := func() error {
				var sDotSizeVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotSizeVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Size.SetTo(sDotSizeVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"size\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetContainerInstanceVolumesPage")
	}

	return nil
}

// EncodeURI encodes GetContainerInstancesTelemetryFilter as URI form.
func (s *GetContainerInstancesTelemetryFilter) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("range-start", func(e uri.Encoder) error {
		if val, ok := s.RangeMinusStart.Get(); ok {
			if unwrapped := time.Time(val); true {
				return e.EncodeValue(conv.DateTimeToString(unwrapped))
			}
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"range-start\"")
	}
	if err := e.EncodeField("range-end", func(e uri.Encoder) error {
		if val, ok := s.RangeMinusEnd.Get(); ok {
			if unwrapped := time.Time(val); true {
				return e.EncodeValue(conv.DateTimeToString(unwrapped))
			}
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"range-end\"")
	}
	return nil
}

var uriFieldsNameOfGetContainerInstancesTelemetryFilter = [2]string{
	0: "range-start",
	1: "range-end",
}

// DecodeURI decodes GetContainerInstancesTelemetryFilter from URI form.
func (s *GetContainerInstancesTelemetryFilter) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetContainerInstancesTelemetryFilter to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "range-start":
			if err := func() error {
				var sDotRangeMinusStartVal DateTime
				if err := func() error {
					var sDotRangeMinusStartValVal time.Time
					if err := func() error {
						val, err := d.DecodeValue()
						if err != nil {
							return err
						}

						c, err := conv.ToDateTime(val)
						if err != nil {
							return err
						}

						sDotRangeMinusStartValVal = c
						return nil
					}(); err != nil {
						return err
					}
					sDotRangeMinusStartVal = DateTime(sDotRangeMinusStartValVal)
					return nil
				}(); err != nil {
					return err
				}
				s.RangeMinusStart.SetTo(sDotRangeMinusStartVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"range-start\"")
			}
		case "range-end":
			if err := func() error {
				var sDotRangeMinusEndVal DateTime
				if err := func() error {
					var sDotRangeMinusEndValVal time.Time
					if err := func() error {
						val, err := d.DecodeValue()
						if err != nil {
							return err
						}

						c, err := conv.ToDateTime(val)
						if err != nil {
							return err
						}

						sDotRangeMinusEndValVal = c
						return nil
					}(); err != nil {
						return err
					}
					sDotRangeMinusEndVal = DateTime(sDotRangeMinusEndValVal)
					return nil
				}(); err != nil {
					return err
				}
				s.RangeMinusEnd.SetTo(sDotRangeMinusEndVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"range-end\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetContainerInstancesTelemetryFilter")
	}

	return nil
}

// EncodeURI encodes GetContainersFilter as URI form.
func (s *GetContainersFilter) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("creator", func(e uri.Encoder) error {
		if val, ok := s.Creator.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"creator\"")
	}
	if err := e.EncodeField("identifier", func(e uri.Encoder) error {
		if val, ok := s.Identifier.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"identifier\"")
	}
	if err := e.EncodeField("search", func(e uri.Encoder) error {
		if val, ok := s.Search.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"search\"")
	}
	if err := e.EncodeField("state", func(e uri.Encoder) error {
		if val, ok := s.State.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"state\"")
	}
	if err := e.EncodeField("service", func(e uri.Encoder) error {
		if val, ok := s.Service.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"service\"")
	}
	if err := e.EncodeField("public_network", func(e uri.Encoder) error {
		if val, ok := s.PublicNetwork.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"public_network\"")
	}
	if err := e.EncodeField("image", func(e uri.Encoder) error {
		if val, ok := s.Image.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"image\"")
	}
	if err := e.EncodeField("environment", func(e uri.Encoder) error {
		if val, ok := s.Environment.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"environment\"")
	}
	if err := e.EncodeField("tags", func(e uri.Encoder) error {
		if val, ok := s.Tags.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"tags\"")
	}
	if err := e.EncodeField("stack", func(e uri.Encoder) error {
		if val, ok := s.Stack.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"stack\"")
	}
	if err := e.EncodeField("deployment", func(e uri.Encoder) error {
		if val, ok := s.Deployment.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"deployment\"")
	}
	if err := e.EncodeField("range-start", func(e uri.Encoder) error {
		if val, ok := s.RangeMinusStart.Get(); ok {
			if unwrapped := time.Time(val); true {
				return e.EncodeValue(conv.DateTimeToString(unwrapped))
			}
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"range-start\"")
	}
	if err := e.EncodeField("range-end", func(e uri.Encoder) error {
		if val, ok := s.RangeMinusEnd.Get(); ok {
			if unwrapped := time.Time(val); true {
				return e.EncodeValue(conv.DateTimeToString(unwrapped))
			}
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"range-end\"")
	}
	return nil
}

var uriFieldsNameOfGetContainersFilter = [13]string{
	0:  "creator",
	1:  "identifier",
	2:  "search",
	3:  "state",
	4:  "service",
	5:  "public_network",
	6:  "image",
	7:  "environment",
	8:  "tags",
	9:  "stack",
	10: "deployment",
	11: "range-start",
	12: "range-end",
}

// DecodeURI decodes GetContainersFilter from URI form.
func (s *GetContainersFilter) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetContainersFilter to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "creator":
			if err := func() error {
				var sDotCreatorVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotCreatorVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Creator.SetTo(sDotCreatorVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"creator\"")
			}
		case "identifier":
			if err := func() error {
				var sDotIdentifierVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotIdentifierVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Identifier.SetTo(sDotIdentifierVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"identifier\"")
			}
		case "search":
			if err := func() error {
				var sDotSearchVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotSearchVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Search.SetTo(sDotSearchVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"search\"")
			}
		case "state":
			if err := func() error {
				var sDotStateVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotStateVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.State.SetTo(sDotStateVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"state\"")
			}
		case "service":
			if err := func() error {
				var sDotServiceVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotServiceVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Service.SetTo(sDotServiceVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"service\"")
			}
		case "public_network":
			if err := func() error {
				var sDotPublicNetworkVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotPublicNetworkVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.PublicNetwork.SetTo(sDotPublicNetworkVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"public_network\"")
			}
		case "image":
			if err := func() error {
				var sDotImageVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotImageVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Image.SetTo(sDotImageVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"image\"")
			}
		case "environment":
			if err := func() error {
				var sDotEnvironmentVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotEnvironmentVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Environment.SetTo(sDotEnvironmentVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"environment\"")
			}
		case "tags":
			if err := func() error {
				var sDotTagsVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotTagsVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Tags.SetTo(sDotTagsVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"tags\"")
			}
		case "stack":
			if err := func() error {
				var sDotStackVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotStackVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Stack.SetTo(sDotStackVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"stack\"")
			}
		case "deployment":
			if err := func() error {
				var sDotDeploymentVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotDeploymentVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Deployment.SetTo(sDotDeploymentVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"deployment\"")
			}
		case "range-start":
			if err := func() error {
				var sDotRangeMinusStartVal DateTime
				if err := func() error {
					var sDotRangeMinusStartValVal time.Time
					if err := func() error {
						val, err := d.DecodeValue()
						if err != nil {
							return err
						}

						c, err := conv.ToDateTime(val)
						if err != nil {
							return err
						}

						sDotRangeMinusStartValVal = c
						return nil
					}(); err != nil {
						return err
					}
					sDotRangeMinusStartVal = DateTime(sDotRangeMinusStartValVal)
					return nil
				}(); err != nil {
					return err
				}
				s.RangeMinusStart.SetTo(sDotRangeMinusStartVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"range-start\"")
			}
		case "range-end":
			if err := func() error {
				var sDotRangeMinusEndVal DateTime
				if err := func() error {
					var sDotRangeMinusEndValVal time.Time
					if err := func() error {
						val, err := d.DecodeValue()
						if err != nil {
							return err
						}

						c, err := conv.ToDateTime(val)
						if err != nil {
							return err
						}

						sDotRangeMinusEndValVal = c
						return nil
					}(); err != nil {
						return err
					}
					sDotRangeMinusEndVal = DateTime(sDotRangeMinusEndValVal)
					return nil
				}(); err != nil {
					return err
				}
				s.RangeMinusEnd.SetTo(sDotRangeMinusEndVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"range-end\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetContainersFilter")
	}

	return nil
}

// EncodeURI encodes GetContainersPage as URI form.
func (s *GetContainersPage) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("number", func(e uri.Encoder) error {
		if val, ok := s.Number.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"number\"")
	}
	if err := e.EncodeField("size", func(e uri.Encoder) error {
		if val, ok := s.Size.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"size\"")
	}
	return nil
}

var uriFieldsNameOfGetContainersPage = [2]string{
	0: "number",
	1: "size",
}

// DecodeURI decodes GetContainersPage from URI form.
func (s *GetContainersPage) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetContainersPage to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "number":
			if err := func() error {
				var sDotNumberVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotNumberVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Number.SetTo(sDotNumberVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"number\"")
			}
		case "size":
			if err := func() error {
				var sDotSizeVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotSizeVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Size.SetTo(sDotSizeVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"size\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetContainersPage")
	}

	return nil
}

// EncodeURI encodes GetCreditsFilter as URI form.
func (s *GetCreditsFilter) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("state", func(e uri.Encoder) error {
		if val, ok := s.State.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"state\"")
	}
	if err := e.EncodeField("range-start", func(e uri.Encoder) error {
		if val, ok := s.RangeMinusStart.Get(); ok {
			if unwrapped := time.Time(val); true {
				return e.EncodeValue(conv.DateTimeToString(unwrapped))
			}
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"range-start\"")
	}
	if err := e.EncodeField("range-end", func(e uri.Encoder) error {
		if val, ok := s.RangeMinusEnd.Get(); ok {
			if unwrapped := time.Time(val); true {
				return e.EncodeValue(conv.DateTimeToString(unwrapped))
			}
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"range-end\"")
	}
	return nil
}

var uriFieldsNameOfGetCreditsFilter = [3]string{
	0: "state",
	1: "range-start",
	2: "range-end",
}

// DecodeURI decodes GetCreditsFilter from URI form.
func (s *GetCreditsFilter) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetCreditsFilter to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "state":
			if err := func() error {
				var sDotStateVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotStateVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.State.SetTo(sDotStateVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"state\"")
			}
		case "range-start":
			if err := func() error {
				var sDotRangeMinusStartVal DateTime
				if err := func() error {
					var sDotRangeMinusStartValVal time.Time
					if err := func() error {
						val, err := d.DecodeValue()
						if err != nil {
							return err
						}

						c, err := conv.ToDateTime(val)
						if err != nil {
							return err
						}

						sDotRangeMinusStartValVal = c
						return nil
					}(); err != nil {
						return err
					}
					sDotRangeMinusStartVal = DateTime(sDotRangeMinusStartValVal)
					return nil
				}(); err != nil {
					return err
				}
				s.RangeMinusStart.SetTo(sDotRangeMinusStartVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"range-start\"")
			}
		case "range-end":
			if err := func() error {
				var sDotRangeMinusEndVal DateTime
				if err := func() error {
					var sDotRangeMinusEndValVal time.Time
					if err := func() error {
						val, err := d.DecodeValue()
						if err != nil {
							return err
						}

						c, err := conv.ToDateTime(val)
						if err != nil {
							return err
						}

						sDotRangeMinusEndValVal = c
						return nil
					}(); err != nil {
						return err
					}
					sDotRangeMinusEndVal = DateTime(sDotRangeMinusEndValVal)
					return nil
				}(); err != nil {
					return err
				}
				s.RangeMinusEnd.SetTo(sDotRangeMinusEndVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"range-end\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetCreditsFilter")
	}

	return nil
}

// EncodeURI encodes GetCreditsPage as URI form.
func (s *GetCreditsPage) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("number", func(e uri.Encoder) error {
		if val, ok := s.Number.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"number\"")
	}
	if err := e.EncodeField("size", func(e uri.Encoder) error {
		if val, ok := s.Size.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"size\"")
	}
	return nil
}

var uriFieldsNameOfGetCreditsPage = [2]string{
	0: "number",
	1: "size",
}

// DecodeURI decodes GetCreditsPage from URI form.
func (s *GetCreditsPage) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetCreditsPage to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "number":
			if err := func() error {
				var sDotNumberVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotNumberVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Number.SetTo(sDotNumberVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"number\"")
			}
		case "size":
			if err := func() error {
				var sDotSizeVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotSizeVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Size.SetTo(sDotSizeVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"size\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetCreditsPage")
	}

	return nil
}

// EncodeURI encodes GetEnvironmentInstancesTelemetryFilter as URI form.
func (s *GetEnvironmentInstancesTelemetryFilter) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("range-start", func(e uri.Encoder) error {
		if val, ok := s.RangeMinusStart.Get(); ok {
			if unwrapped := time.Time(val); true {
				return e.EncodeValue(conv.DateTimeToString(unwrapped))
			}
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"range-start\"")
	}
	if err := e.EncodeField("range-end", func(e uri.Encoder) error {
		if val, ok := s.RangeMinusEnd.Get(); ok {
			if unwrapped := time.Time(val); true {
				return e.EncodeValue(conv.DateTimeToString(unwrapped))
			}
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"range-end\"")
	}
	return nil
}

var uriFieldsNameOfGetEnvironmentInstancesTelemetryFilter = [2]string{
	0: "range-start",
	1: "range-end",
}

// DecodeURI decodes GetEnvironmentInstancesTelemetryFilter from URI form.
func (s *GetEnvironmentInstancesTelemetryFilter) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetEnvironmentInstancesTelemetryFilter to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "range-start":
			if err := func() error {
				var sDotRangeMinusStartVal DateTime
				if err := func() error {
					var sDotRangeMinusStartValVal time.Time
					if err := func() error {
						val, err := d.DecodeValue()
						if err != nil {
							return err
						}

						c, err := conv.ToDateTime(val)
						if err != nil {
							return err
						}

						sDotRangeMinusStartValVal = c
						return nil
					}(); err != nil {
						return err
					}
					sDotRangeMinusStartVal = DateTime(sDotRangeMinusStartValVal)
					return nil
				}(); err != nil {
					return err
				}
				s.RangeMinusStart.SetTo(sDotRangeMinusStartVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"range-start\"")
			}
		case "range-end":
			if err := func() error {
				var sDotRangeMinusEndVal DateTime
				if err := func() error {
					var sDotRangeMinusEndValVal time.Time
					if err := func() error {
						val, err := d.DecodeValue()
						if err != nil {
							return err
						}

						c, err := conv.ToDateTime(val)
						if err != nil {
							return err
						}

						sDotRangeMinusEndValVal = c
						return nil
					}(); err != nil {
						return err
					}
					sDotRangeMinusEndVal = DateTime(sDotRangeMinusEndValVal)
					return nil
				}(); err != nil {
					return err
				}
				s.RangeMinusEnd.SetTo(sDotRangeMinusEndVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"range-end\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetEnvironmentInstancesTelemetryFilter")
	}

	return nil
}

// EncodeURI encodes GetEnvironmentsFilter as URI form.
func (s *GetEnvironmentsFilter) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("creator", func(e uri.Encoder) error {
		if val, ok := s.Creator.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"creator\"")
	}
	if err := e.EncodeField("identifier", func(e uri.Encoder) error {
		if val, ok := s.Identifier.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"identifier\"")
	}
	if err := e.EncodeField("search", func(e uri.Encoder) error {
		if val, ok := s.Search.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"search\"")
	}
	if err := e.EncodeField("state", func(e uri.Encoder) error {
		if val, ok := s.State.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"state\"")
	}
	if err := e.EncodeField("stack_build", func(e uri.Encoder) error {
		if val, ok := s.StackBuild.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"stack_build\"")
	}
	return nil
}

var uriFieldsNameOfGetEnvironmentsFilter = [5]string{
	0: "creator",
	1: "identifier",
	2: "search",
	3: "state",
	4: "stack_build",
}

// DecodeURI decodes GetEnvironmentsFilter from URI form.
func (s *GetEnvironmentsFilter) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetEnvironmentsFilter to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "creator":
			if err := func() error {
				var sDotCreatorVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotCreatorVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Creator.SetTo(sDotCreatorVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"creator\"")
			}
		case "identifier":
			if err := func() error {
				var sDotIdentifierVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotIdentifierVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Identifier.SetTo(sDotIdentifierVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"identifier\"")
			}
		case "search":
			if err := func() error {
				var sDotSearchVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotSearchVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Search.SetTo(sDotSearchVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"search\"")
			}
		case "state":
			if err := func() error {
				var sDotStateVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotStateVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.State.SetTo(sDotStateVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"state\"")
			}
		case "stack_build":
			if err := func() error {
				var sDotStackBuildVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotStackBuildVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.StackBuild.SetTo(sDotStackBuildVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"stack_build\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetEnvironmentsFilter")
	}

	return nil
}

// EncodeURI encodes GetEnvironmentsPage as URI form.
func (s *GetEnvironmentsPage) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("number", func(e uri.Encoder) error {
		if val, ok := s.Number.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"number\"")
	}
	if err := e.EncodeField("size", func(e uri.Encoder) error {
		if val, ok := s.Size.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"size\"")
	}
	return nil
}

var uriFieldsNameOfGetEnvironmentsPage = [2]string{
	0: "number",
	1: "size",
}

// DecodeURI decodes GetEnvironmentsPage from URI form.
func (s *GetEnvironmentsPage) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetEnvironmentsPage to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "number":
			if err := func() error {
				var sDotNumberVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotNumberVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Number.SetTo(sDotNumberVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"number\"")
			}
		case "size":
			if err := func() error {
				var sDotSizeVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotSizeVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Size.SetTo(sDotSizeVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"size\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetEnvironmentsPage")
	}

	return nil
}

// EncodeURI encodes GetHubInvitesFilter as URI form.
func (s *GetHubInvitesFilter) EncodeURI(e uri.Encoder) error {
	return nil
}

var uriFieldsNameOfGetHubInvitesFilter = [0]string{}

// DecodeURI decodes GetHubInvitesFilter from URI form.
func (s *GetHubInvitesFilter) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetHubInvitesFilter to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetHubInvitesFilter")
	}

	return nil
}

// EncodeURI encodes GetHubInvitesPage as URI form.
func (s *GetHubInvitesPage) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("number", func(e uri.Encoder) error {
		if val, ok := s.Number.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"number\"")
	}
	if err := e.EncodeField("size", func(e uri.Encoder) error {
		if val, ok := s.Size.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"size\"")
	}
	return nil
}

var uriFieldsNameOfGetHubInvitesPage = [2]string{
	0: "number",
	1: "size",
}

// DecodeURI decodes GetHubInvitesPage from URI form.
func (s *GetHubInvitesPage) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetHubInvitesPage to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "number":
			if err := func() error {
				var sDotNumberVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotNumberVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Number.SetTo(sDotNumberVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"number\"")
			}
		case "size":
			if err := func() error {
				var sDotSizeVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotSizeVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Size.SetTo(sDotSizeVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"size\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetHubInvitesPage")
	}

	return nil
}

// EncodeURI encodes GetHubMembersFilter as URI form.
func (s *GetHubMembersFilter) EncodeURI(e uri.Encoder) error {
	return nil
}

var uriFieldsNameOfGetHubMembersFilter = [0]string{}

// DecodeURI decodes GetHubMembersFilter from URI form.
func (s *GetHubMembersFilter) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetHubMembersFilter to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetHubMembersFilter")
	}

	return nil
}

// EncodeURI encodes GetHubMembersPage as URI form.
func (s *GetHubMembersPage) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("number", func(e uri.Encoder) error {
		if val, ok := s.Number.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"number\"")
	}
	if err := e.EncodeField("size", func(e uri.Encoder) error {
		if val, ok := s.Size.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"size\"")
	}
	return nil
}

var uriFieldsNameOfGetHubMembersPage = [2]string{
	0: "number",
	1: "size",
}

// DecodeURI decodes GetHubMembersPage from URI form.
func (s *GetHubMembersPage) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetHubMembersPage to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "number":
			if err := func() error {
				var sDotNumberVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotNumberVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Number.SetTo(sDotNumberVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"number\"")
			}
		case "size":
			if err := func() error {
				var sDotSizeVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotSizeVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Size.SetTo(sDotSizeVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"size\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetHubMembersPage")
	}

	return nil
}

// EncodeURI encodes GetHubMembershipFilter as URI form.
func (s *GetHubMembershipFilter) EncodeURI(e uri.Encoder) error {
	return nil
}

var uriFieldsNameOfGetHubMembershipFilter = [0]string{}

// DecodeURI decodes GetHubMembershipFilter from URI form.
func (s *GetHubMembershipFilter) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetHubMembershipFilter to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetHubMembershipFilter")
	}

	return nil
}

// EncodeURI encodes GetHubMembershipPage as URI form.
func (s *GetHubMembershipPage) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("number", func(e uri.Encoder) error {
		if val, ok := s.Number.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"number\"")
	}
	if err := e.EncodeField("size", func(e uri.Encoder) error {
		if val, ok := s.Size.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"size\"")
	}
	return nil
}

var uriFieldsNameOfGetHubMembershipPage = [2]string{
	0: "number",
	1: "size",
}

// DecodeURI decodes GetHubMembershipPage from URI form.
func (s *GetHubMembershipPage) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetHubMembershipPage to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "number":
			if err := func() error {
				var sDotNumberVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotNumberVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Number.SetTo(sDotNumberVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"number\"")
			}
		case "size":
			if err := func() error {
				var sDotSizeVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotSizeVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Size.SetTo(sDotSizeVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"size\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetHubMembershipPage")
	}

	return nil
}

// EncodeURI encodes GetHubUsageFilter as URI form.
func (s *GetHubUsageFilter) EncodeURI(e uri.Encoder) error {
	return nil
}

var uriFieldsNameOfGetHubUsageFilter = [0]string{}

// DecodeURI decodes GetHubUsageFilter from URI form.
func (s *GetHubUsageFilter) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetHubUsageFilter to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetHubUsageFilter")
	}

	return nil
}

// EncodeURI encodes GetHubsFilter as URI form.
func (s *GetHubsFilter) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("identifier", func(e uri.Encoder) error {
		if val, ok := s.Identifier.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"identifier\"")
	}
	if err := e.EncodeField("search", func(e uri.Encoder) error {
		if val, ok := s.Search.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"search\"")
	}
	if err := e.EncodeField("state", func(e uri.Encoder) error {
		if val, ok := s.State.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"state\"")
	}
	return nil
}

var uriFieldsNameOfGetHubsFilter = [3]string{
	0: "identifier",
	1: "search",
	2: "state",
}

// DecodeURI decodes GetHubsFilter from URI form.
func (s *GetHubsFilter) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetHubsFilter to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "identifier":
			if err := func() error {
				var sDotIdentifierVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotIdentifierVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Identifier.SetTo(sDotIdentifierVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"identifier\"")
			}
		case "search":
			if err := func() error {
				var sDotSearchVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotSearchVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Search.SetTo(sDotSearchVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"search\"")
			}
		case "state":
			if err := func() error {
				var sDotStateVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotStateVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.State.SetTo(sDotStateVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"state\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetHubsFilter")
	}

	return nil
}

// EncodeURI encodes GetHubsPage as URI form.
func (s *GetHubsPage) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("number", func(e uri.Encoder) error {
		if val, ok := s.Number.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"number\"")
	}
	if err := e.EncodeField("size", func(e uri.Encoder) error {
		if val, ok := s.Size.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"size\"")
	}
	return nil
}

var uriFieldsNameOfGetHubsPage = [2]string{
	0: "number",
	1: "size",
}

// DecodeURI decodes GetHubsPage from URI form.
func (s *GetHubsPage) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetHubsPage to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "number":
			if err := func() error {
				var sDotNumberVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotNumberVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Number.SetTo(sDotNumberVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"number\"")
			}
		case "size":
			if err := func() error {
				var sDotSizeVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotSizeVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Size.SetTo(sDotSizeVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"size\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetHubsPage")
	}

	return nil
}

// EncodeURI encodes GetImagePage as URI form.
func (s *GetImagePage) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("number", func(e uri.Encoder) error {
		if val, ok := s.Number.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"number\"")
	}
	if err := e.EncodeField("size", func(e uri.Encoder) error {
		if val, ok := s.Size.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"size\"")
	}
	return nil
}

var uriFieldsNameOfGetImagePage = [2]string{
	0: "number",
	1: "size",
}

// DecodeURI decodes GetImagePage from URI form.
func (s *GetImagePage) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetImagePage to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "number":
			if err := func() error {
				var sDotNumberVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotNumberVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Number.SetTo(sDotNumberVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"number\"")
			}
		case "size":
			if err := func() error {
				var sDotSizeVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotSizeVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Size.SetTo(sDotSizeVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"size\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetImagePage")
	}

	return nil
}

// EncodeURI encodes GetImagesFilter as URI form.
func (s *GetImagesFilter) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("identifier", func(e uri.Encoder) error {
		if val, ok := s.Identifier.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"identifier\"")
	}
	if err := e.EncodeField("search", func(e uri.Encoder) error {
		if val, ok := s.Search.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"search\"")
	}
	if err := e.EncodeField("state", func(e uri.Encoder) error {
		if val, ok := s.State.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"state\"")
	}
	if err := e.EncodeField("source_type", func(e uri.Encoder) error {
		if val, ok := s.SourceType.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"source_type\"")
	}
	if err := e.EncodeField("source_id", func(e uri.Encoder) error {
		if val, ok := s.SourceID.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"source_id\"")
	}
	return nil
}

var uriFieldsNameOfGetImagesFilter = [5]string{
	0: "identifier",
	1: "search",
	2: "state",
	3: "source_type",
	4: "source_id",
}

// DecodeURI decodes GetImagesFilter from URI form.
func (s *GetImagesFilter) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetImagesFilter to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "identifier":
			if err := func() error {
				var sDotIdentifierVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotIdentifierVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Identifier.SetTo(sDotIdentifierVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"identifier\"")
			}
		case "search":
			if err := func() error {
				var sDotSearchVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotSearchVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Search.SetTo(sDotSearchVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"search\"")
			}
		case "state":
			if err := func() error {
				var sDotStateVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotStateVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.State.SetTo(sDotStateVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"state\"")
			}
		case "source_type":
			if err := func() error {
				var sDotSourceTypeVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotSourceTypeVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.SourceType.SetTo(sDotSourceTypeVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"source_type\"")
			}
		case "source_id":
			if err := func() error {
				var sDotSourceIDVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotSourceIDVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.SourceID.SetTo(sDotSourceIDVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"source_id\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetImagesFilter")
	}

	return nil
}

// EncodeURI encodes GetImagesPage as URI form.
func (s *GetImagesPage) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("number", func(e uri.Encoder) error {
		if val, ok := s.Number.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"number\"")
	}
	if err := e.EncodeField("size", func(e uri.Encoder) error {
		if val, ok := s.Size.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"size\"")
	}
	return nil
}

var uriFieldsNameOfGetImagesPage = [2]string{
	0: "number",
	1: "size",
}

// DecodeURI decodes GetImagesPage from URI form.
func (s *GetImagesPage) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetImagesPage to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "number":
			if err := func() error {
				var sDotNumberVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotNumberVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Number.SetTo(sDotNumberVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"number\"")
			}
		case "size":
			if err := func() error {
				var sDotSizeVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotSizeVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Size.SetTo(sDotSizeVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"size\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetImagesPage")
	}

	return nil
}

// EncodeURI encodes GetInfrastructureIPPoolsPage as URI form.
func (s *GetInfrastructureIPPoolsPage) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("number", func(e uri.Encoder) error {
		if val, ok := s.Number.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"number\"")
	}
	if err := e.EncodeField("size", func(e uri.Encoder) error {
		if val, ok := s.Size.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"size\"")
	}
	return nil
}

var uriFieldsNameOfGetInfrastructureIPPoolsPage = [2]string{
	0: "number",
	1: "size",
}

// DecodeURI decodes GetInfrastructureIPPoolsPage from URI form.
func (s *GetInfrastructureIPPoolsPage) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetInfrastructureIPPoolsPage to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "number":
			if err := func() error {
				var sDotNumberVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotNumberVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Number.SetTo(sDotNumberVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"number\"")
			}
		case "size":
			if err := func() error {
				var sDotSizeVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotSizeVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Size.SetTo(sDotSizeVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"size\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetInfrastructureIPPoolsPage")
	}

	return nil
}

// EncodeURI encodes GetInfrastructureSummaryFilter as URI form.
func (s *GetInfrastructureSummaryFilter) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("cluster", func(e uri.Encoder) error {
		if val, ok := s.Cluster.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"cluster\"")
	}
	return nil
}

var uriFieldsNameOfGetInfrastructureSummaryFilter = [1]string{
	0: "cluster",
}

// DecodeURI decodes GetInfrastructureSummaryFilter from URI form.
func (s *GetInfrastructureSummaryFilter) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetInfrastructureSummaryFilter to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "cluster":
			if err := func() error {
				var sDotClusterVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotClusterVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Cluster.SetTo(sDotClusterVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cluster\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetInfrastructureSummaryFilter")
	}

	return nil
}

// EncodeURI encodes GetInstanceResourcesTelemetryReportFilter as URI form.
func (s *GetInstanceResourcesTelemetryReportFilter) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("range-start", func(e uri.Encoder) error {
		if val, ok := s.RangeMinusStart.Get(); ok {
			if unwrapped := time.Time(val); true {
				return e.EncodeValue(conv.DateTimeToString(unwrapped))
			}
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"range-start\"")
	}
	if err := e.EncodeField("range-end", func(e uri.Encoder) error {
		if val, ok := s.RangeMinusEnd.Get(); ok {
			if unwrapped := time.Time(val); true {
				return e.EncodeValue(conv.DateTimeToString(unwrapped))
			}
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"range-end\"")
	}
	return nil
}

var uriFieldsNameOfGetInstanceResourcesTelemetryReportFilter = [2]string{
	0: "range-start",
	1: "range-end",
}

// DecodeURI decodes GetInstanceResourcesTelemetryReportFilter from URI form.
func (s *GetInstanceResourcesTelemetryReportFilter) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetInstanceResourcesTelemetryReportFilter to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "range-start":
			if err := func() error {
				var sDotRangeMinusStartVal DateTime
				if err := func() error {
					var sDotRangeMinusStartValVal time.Time
					if err := func() error {
						val, err := d.DecodeValue()
						if err != nil {
							return err
						}

						c, err := conv.ToDateTime(val)
						if err != nil {
							return err
						}

						sDotRangeMinusStartValVal = c
						return nil
					}(); err != nil {
						return err
					}
					sDotRangeMinusStartVal = DateTime(sDotRangeMinusStartValVal)
					return nil
				}(); err != nil {
					return err
				}
				s.RangeMinusStart.SetTo(sDotRangeMinusStartVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"range-start\"")
			}
		case "range-end":
			if err := func() error {
				var sDotRangeMinusEndVal DateTime
				if err := func() error {
					var sDotRangeMinusEndValVal time.Time
					if err := func() error {
						val, err := d.DecodeValue()
						if err != nil {
							return err
						}

						c, err := conv.ToDateTime(val)
						if err != nil {
							return err
						}

						sDotRangeMinusEndValVal = c
						return nil
					}(); err != nil {
						return err
					}
					sDotRangeMinusEndVal = DateTime(sDotRangeMinusEndValVal)
					return nil
				}(); err != nil {
					return err
				}
				s.RangeMinusEnd.SetTo(sDotRangeMinusEndVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"range-end\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetInstanceResourcesTelemetryReportFilter")
	}

	return nil
}

// EncodeURI encodes GetInstancesFilter as URI form.
func (s *GetInstancesFilter) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("state", func(e uri.Encoder) error {
		if val, ok := s.State.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"state\"")
	}
	if err := e.EncodeField("search", func(e uri.Encoder) error {
		if val, ok := s.Search.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"search\"")
	}
	if err := e.EncodeField("server", func(e uri.Encoder) error {
		if val, ok := s.Server.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"server\"")
	}
	if err := e.EncodeField("range-start", func(e uri.Encoder) error {
		if val, ok := s.RangeMinusStart.Get(); ok {
			if unwrapped := time.Time(val); true {
				return e.EncodeValue(conv.DateTimeToString(unwrapped))
			}
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"range-start\"")
	}
	if err := e.EncodeField("range-end", func(e uri.Encoder) error {
		if val, ok := s.RangeMinusEnd.Get(); ok {
			if unwrapped := time.Time(val); true {
				return e.EncodeValue(conv.DateTimeToString(unwrapped))
			}
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"range-end\"")
	}
	return nil
}

var uriFieldsNameOfGetInstancesFilter = [5]string{
	0: "state",
	1: "search",
	2: "server",
	3: "range-start",
	4: "range-end",
}

// DecodeURI decodes GetInstancesFilter from URI form.
func (s *GetInstancesFilter) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetInstancesFilter to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "state":
			if err := func() error {
				var sDotStateVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotStateVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.State.SetTo(sDotStateVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"state\"")
			}
		case "search":
			if err := func() error {
				var sDotSearchVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotSearchVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Search.SetTo(sDotSearchVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"search\"")
			}
		case "server":
			if err := func() error {
				var sDotServerVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotServerVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Server.SetTo(sDotServerVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"server\"")
			}
		case "range-start":
			if err := func() error {
				var sDotRangeMinusStartVal DateTime
				if err := func() error {
					var sDotRangeMinusStartValVal time.Time
					if err := func() error {
						val, err := d.DecodeValue()
						if err != nil {
							return err
						}

						c, err := conv.ToDateTime(val)
						if err != nil {
							return err
						}

						sDotRangeMinusStartValVal = c
						return nil
					}(); err != nil {
						return err
					}
					sDotRangeMinusStartVal = DateTime(sDotRangeMinusStartValVal)
					return nil
				}(); err != nil {
					return err
				}
				s.RangeMinusStart.SetTo(sDotRangeMinusStartVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"range-start\"")
			}
		case "range-end":
			if err := func() error {
				var sDotRangeMinusEndVal DateTime
				if err := func() error {
					var sDotRangeMinusEndValVal time.Time
					if err := func() error {
						val, err := d.DecodeValue()
						if err != nil {
							return err
						}

						c, err := conv.ToDateTime(val)
						if err != nil {
							return err
						}

						sDotRangeMinusEndValVal = c
						return nil
					}(); err != nil {
						return err
					}
					sDotRangeMinusEndVal = DateTime(sDotRangeMinusEndValVal)
					return nil
				}(); err != nil {
					return err
				}
				s.RangeMinusEnd.SetTo(sDotRangeMinusEndVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"range-end\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetInstancesFilter")
	}

	return nil
}

// EncodeURI encodes GetInstancesPage as URI form.
func (s *GetInstancesPage) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("number", func(e uri.Encoder) error {
		if val, ok := s.Number.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"number\"")
	}
	if err := e.EncodeField("size", func(e uri.Encoder) error {
		if val, ok := s.Size.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"size\"")
	}
	return nil
}

var uriFieldsNameOfGetInstancesPage = [2]string{
	0: "number",
	1: "size",
}

// DecodeURI decodes GetInstancesPage from URI form.
func (s *GetInstancesPage) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetInstancesPage to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "number":
			if err := func() error {
				var sDotNumberVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotNumberVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Number.SetTo(sDotNumberVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"number\"")
			}
		case "size":
			if err := func() error {
				var sDotSizeVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotSizeVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Size.SetTo(sDotSizeVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"size\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetInstancesPage")
	}

	return nil
}

// EncodeURI encodes GetInvoicesFilter as URI form.
func (s *GetInvoicesFilter) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("state", func(e uri.Encoder) error {
		if val, ok := s.State.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"state\"")
	}
	if err := e.EncodeField("range-start", func(e uri.Encoder) error {
		if val, ok := s.RangeMinusStart.Get(); ok {
			if unwrapped := time.Time(val); true {
				return e.EncodeValue(conv.DateTimeToString(unwrapped))
			}
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"range-start\"")
	}
	if err := e.EncodeField("range-end", func(e uri.Encoder) error {
		if val, ok := s.RangeMinusEnd.Get(); ok {
			if unwrapped := time.Time(val); true {
				return e.EncodeValue(conv.DateTimeToString(unwrapped))
			}
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"range-end\"")
	}
	return nil
}

var uriFieldsNameOfGetInvoicesFilter = [3]string{
	0: "state",
	1: "range-start",
	2: "range-end",
}

// DecodeURI decodes GetInvoicesFilter from URI form.
func (s *GetInvoicesFilter) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetInvoicesFilter to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "state":
			if err := func() error {
				var sDotStateVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotStateVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.State.SetTo(sDotStateVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"state\"")
			}
		case "range-start":
			if err := func() error {
				var sDotRangeMinusStartVal DateTime
				if err := func() error {
					var sDotRangeMinusStartValVal time.Time
					if err := func() error {
						val, err := d.DecodeValue()
						if err != nil {
							return err
						}

						c, err := conv.ToDateTime(val)
						if err != nil {
							return err
						}

						sDotRangeMinusStartValVal = c
						return nil
					}(); err != nil {
						return err
					}
					sDotRangeMinusStartVal = DateTime(sDotRangeMinusStartValVal)
					return nil
				}(); err != nil {
					return err
				}
				s.RangeMinusStart.SetTo(sDotRangeMinusStartVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"range-start\"")
			}
		case "range-end":
			if err := func() error {
				var sDotRangeMinusEndVal DateTime
				if err := func() error {
					var sDotRangeMinusEndValVal time.Time
					if err := func() error {
						val, err := d.DecodeValue()
						if err != nil {
							return err
						}

						c, err := conv.ToDateTime(val)
						if err != nil {
							return err
						}

						sDotRangeMinusEndValVal = c
						return nil
					}(); err != nil {
						return err
					}
					sDotRangeMinusEndVal = DateTime(sDotRangeMinusEndValVal)
					return nil
				}(); err != nil {
					return err
				}
				s.RangeMinusEnd.SetTo(sDotRangeMinusEndVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"range-end\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetInvoicesFilter")
	}

	return nil
}

// EncodeURI encodes GetInvoicesPage as URI form.
func (s *GetInvoicesPage) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("number", func(e uri.Encoder) error {
		if val, ok := s.Number.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"number\"")
	}
	if err := e.EncodeField("size", func(e uri.Encoder) error {
		if val, ok := s.Size.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"size\"")
	}
	return nil
}

var uriFieldsNameOfGetInvoicesPage = [2]string{
	0: "number",
	1: "size",
}

// DecodeURI decodes GetInvoicesPage from URI form.
func (s *GetInvoicesPage) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetInvoicesPage to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "number":
			if err := func() error {
				var sDotNumberVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotNumberVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Number.SetTo(sDotNumberVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"number\"")
			}
		case "size":
			if err := func() error {
				var sDotSizeVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotSizeVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Size.SetTo(sDotSizeVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"size\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetInvoicesPage")
	}

	return nil
}

// EncodeURI encodes GetJobsFilter as URI form.
func (s *GetJobsFilter) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("range-start", func(e uri.Encoder) error {
		if val, ok := s.RangeMinusStart.Get(); ok {
			if unwrapped := time.Time(val); true {
				return e.EncodeValue(conv.DateTimeToString(unwrapped))
			}
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"range-start\"")
	}
	if err := e.EncodeField("range-end", func(e uri.Encoder) error {
		if val, ok := s.RangeMinusEnd.Get(); ok {
			if unwrapped := time.Time(val); true {
				return e.EncodeValue(conv.DateTimeToString(unwrapped))
			}
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"range-end\"")
	}
	if err := e.EncodeField("search", func(e uri.Encoder) error {
		if val, ok := s.Search.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"search\"")
	}
	if err := e.EncodeField("state", func(e uri.Encoder) error {
		if val, ok := s.State.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"state\"")
	}
	return nil
}

var uriFieldsNameOfGetJobsFilter = [4]string{
	0: "range-start",
	1: "range-end",
	2: "search",
	3: "state",
}

// DecodeURI decodes GetJobsFilter from URI form.
func (s *GetJobsFilter) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetJobsFilter to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "range-start":
			if err := func() error {
				var sDotRangeMinusStartVal DateTime
				if err := func() error {
					var sDotRangeMinusStartValVal time.Time
					if err := func() error {
						val, err := d.DecodeValue()
						if err != nil {
							return err
						}

						c, err := conv.ToDateTime(val)
						if err != nil {
							return err
						}

						sDotRangeMinusStartValVal = c
						return nil
					}(); err != nil {
						return err
					}
					sDotRangeMinusStartVal = DateTime(sDotRangeMinusStartValVal)
					return nil
				}(); err != nil {
					return err
				}
				s.RangeMinusStart.SetTo(sDotRangeMinusStartVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"range-start\"")
			}
		case "range-end":
			if err := func() error {
				var sDotRangeMinusEndVal DateTime
				if err := func() error {
					var sDotRangeMinusEndValVal time.Time
					if err := func() error {
						val, err := d.DecodeValue()
						if err != nil {
							return err
						}

						c, err := conv.ToDateTime(val)
						if err != nil {
							return err
						}

						sDotRangeMinusEndValVal = c
						return nil
					}(); err != nil {
						return err
					}
					sDotRangeMinusEndVal = DateTime(sDotRangeMinusEndValVal)
					return nil
				}(); err != nil {
					return err
				}
				s.RangeMinusEnd.SetTo(sDotRangeMinusEndVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"range-end\"")
			}
		case "search":
			if err := func() error {
				var sDotSearchVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotSearchVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Search.SetTo(sDotSearchVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"search\"")
			}
		case "state":
			if err := func() error {
				var sDotStateVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotStateVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.State.SetTo(sDotStateVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"state\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetJobsFilter")
	}

	return nil
}

// EncodeURI encodes GetJobsPage as URI form.
func (s *GetJobsPage) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("number", func(e uri.Encoder) error {
		if val, ok := s.Number.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"number\"")
	}
	if err := e.EncodeField("size", func(e uri.Encoder) error {
		if val, ok := s.Size.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"size\"")
	}
	return nil
}

var uriFieldsNameOfGetJobsPage = [2]string{
	0: "number",
	1: "size",
}

// DecodeURI decodes GetJobsPage from URI form.
func (s *GetJobsPage) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetJobsPage to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "number":
			if err := func() error {
				var sDotNumberVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotNumberVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Number.SetTo(sDotNumberVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"number\"")
			}
		case "size":
			if err := func() error {
				var sDotSizeVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotSizeVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Size.SetTo(sDotSizeVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"size\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetJobsPage")
	}

	return nil
}

// EncodeURI encodes GetLoadBalancerLatestTelemetryReportFilter as URI form.
func (s *GetLoadBalancerLatestTelemetryReportFilter) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("controller", func(e uri.Encoder) error {
		if val, ok := s.Controller.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"controller\"")
	}
	return nil
}

var uriFieldsNameOfGetLoadBalancerLatestTelemetryReportFilter = [1]string{
	0: "controller",
}

// DecodeURI decodes GetLoadBalancerLatestTelemetryReportFilter from URI form.
func (s *GetLoadBalancerLatestTelemetryReportFilter) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetLoadBalancerLatestTelemetryReportFilter to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "controller":
			if err := func() error {
				var sDotControllerVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotControllerVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Controller.SetTo(sDotControllerVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"controller\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetLoadBalancerLatestTelemetryReportFilter")
	}

	return nil
}

// EncodeURI encodes GetLoadBalancerTelemetryReportFilter as URI form.
func (s *GetLoadBalancerTelemetryReportFilter) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("range-start", func(e uri.Encoder) error {
		if val, ok := s.RangeMinusStart.Get(); ok {
			if unwrapped := time.Time(val); true {
				return e.EncodeValue(conv.DateTimeToString(unwrapped))
			}
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"range-start\"")
	}
	if err := e.EncodeField("range-end", func(e uri.Encoder) error {
		if val, ok := s.RangeMinusEnd.Get(); ok {
			if unwrapped := time.Time(val); true {
				return e.EncodeValue(conv.DateTimeToString(unwrapped))
			}
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"range-end\"")
	}
	return nil
}

var uriFieldsNameOfGetLoadBalancerTelemetryReportFilter = [2]string{
	0: "range-start",
	1: "range-end",
}

// DecodeURI decodes GetLoadBalancerTelemetryReportFilter from URI form.
func (s *GetLoadBalancerTelemetryReportFilter) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetLoadBalancerTelemetryReportFilter to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "range-start":
			if err := func() error {
				var sDotRangeMinusStartVal DateTime
				if err := func() error {
					var sDotRangeMinusStartValVal time.Time
					if err := func() error {
						val, err := d.DecodeValue()
						if err != nil {
							return err
						}

						c, err := conv.ToDateTime(val)
						if err != nil {
							return err
						}

						sDotRangeMinusStartValVal = c
						return nil
					}(); err != nil {
						return err
					}
					sDotRangeMinusStartVal = DateTime(sDotRangeMinusStartValVal)
					return nil
				}(); err != nil {
					return err
				}
				s.RangeMinusStart.SetTo(sDotRangeMinusStartVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"range-start\"")
			}
		case "range-end":
			if err := func() error {
				var sDotRangeMinusEndVal DateTime
				if err := func() error {
					var sDotRangeMinusEndValVal time.Time
					if err := func() error {
						val, err := d.DecodeValue()
						if err != nil {
							return err
						}

						c, err := conv.ToDateTime(val)
						if err != nil {
							return err
						}

						sDotRangeMinusEndValVal = c
						return nil
					}(); err != nil {
						return err
					}
					sDotRangeMinusEndVal = DateTime(sDotRangeMinusEndValVal)
					return nil
				}(); err != nil {
					return err
				}
				s.RangeMinusEnd.SetTo(sDotRangeMinusEndVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"range-end\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetLoadBalancerTelemetryReportFilter")
	}

	return nil
}

// EncodeURI encodes GetNativeProvidersFilter as URI form.
func (s *GetNativeProvidersFilter) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("search", func(e uri.Encoder) error {
		if val, ok := s.Search.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"search\"")
	}
	return nil
}

var uriFieldsNameOfGetNativeProvidersFilter = [1]string{
	0: "search",
}

// DecodeURI decodes GetNativeProvidersFilter from URI form.
func (s *GetNativeProvidersFilter) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetNativeProvidersFilter to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "search":
			if err := func() error {
				var sDotSearchVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotSearchVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Search.SetTo(sDotSearchVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"search\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetNativeProvidersFilter")
	}

	return nil
}

// EncodeURI encodes GetNativeProvidersPage as URI form.
func (s *GetNativeProvidersPage) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("number", func(e uri.Encoder) error {
		if val, ok := s.Number.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"number\"")
	}
	if err := e.EncodeField("size", func(e uri.Encoder) error {
		if val, ok := s.Size.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"size\"")
	}
	return nil
}

var uriFieldsNameOfGetNativeProvidersPage = [2]string{
	0: "number",
	1: "size",
}

// DecodeURI decodes GetNativeProvidersPage from URI form.
func (s *GetNativeProvidersPage) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetNativeProvidersPage to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "number":
			if err := func() error {
				var sDotNumberVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotNumberVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Number.SetTo(sDotNumberVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"number\"")
			}
		case "size":
			if err := func() error {
				var sDotSizeVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotSizeVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Size.SetTo(sDotSizeVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"size\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetNativeProvidersPage")
	}

	return nil
}

// EncodeURI encodes GetNetworksFilter as URI form.
func (s *GetNetworksFilter) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("search", func(e uri.Encoder) error {
		if val, ok := s.Search.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"search\"")
	}
	if err := e.EncodeField("state", func(e uri.Encoder) error {
		if val, ok := s.State.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"state\"")
	}
	return nil
}

var uriFieldsNameOfGetNetworksFilter = [2]string{
	0: "search",
	1: "state",
}

// DecodeURI decodes GetNetworksFilter from URI form.
func (s *GetNetworksFilter) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetNetworksFilter to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "search":
			if err := func() error {
				var sDotSearchVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotSearchVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Search.SetTo(sDotSearchVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"search\"")
			}
		case "state":
			if err := func() error {
				var sDotStateVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotStateVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.State.SetTo(sDotStateVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"state\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetNetworksFilter")
	}

	return nil
}

// EncodeURI encodes GetNetworksPage as URI form.
func (s *GetNetworksPage) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("number", func(e uri.Encoder) error {
		if val, ok := s.Number.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"number\"")
	}
	if err := e.EncodeField("size", func(e uri.Encoder) error {
		if val, ok := s.Size.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"size\"")
	}
	return nil
}

var uriFieldsNameOfGetNetworksPage = [2]string{
	0: "number",
	1: "size",
}

// DecodeURI decodes GetNetworksPage from URI form.
func (s *GetNetworksPage) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetNetworksPage to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "number":
			if err := func() error {
				var sDotNumberVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotNumberVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Number.SetTo(sDotNumberVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"number\"")
			}
		case "size":
			if err := func() error {
				var sDotSizeVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotSizeVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Size.SetTo(sDotSizeVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"size\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetNetworksPage")
	}

	return nil
}

// EncodeURI encodes GetOrdersFilter as URI form.
func (s *GetOrdersFilter) EncodeURI(e uri.Encoder) error {
	return nil
}

var uriFieldsNameOfGetOrdersFilter = [0]string{}

// DecodeURI decodes GetOrdersFilter from URI form.
func (s *GetOrdersFilter) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetOrdersFilter to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetOrdersFilter")
	}

	return nil
}

// EncodeURI encodes GetOrdersPage as URI form.
func (s *GetOrdersPage) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("number", func(e uri.Encoder) error {
		if val, ok := s.Number.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"number\"")
	}
	if err := e.EncodeField("size", func(e uri.Encoder) error {
		if val, ok := s.Size.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"size\"")
	}
	return nil
}

var uriFieldsNameOfGetOrdersPage = [2]string{
	0: "number",
	1: "size",
}

// DecodeURI decodes GetOrdersPage from URI form.
func (s *GetOrdersPage) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetOrdersPage to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "number":
			if err := func() error {
				var sDotNumberVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotNumberVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Number.SetTo(sDotNumberVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"number\"")
			}
		case "size":
			if err := func() error {
				var sDotSizeVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotSizeVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Size.SetTo(sDotSizeVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"size\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetOrdersPage")
	}

	return nil
}

// EncodeURI encodes GetPipelineTriggerKeysFilter as URI form.
func (s *GetPipelineTriggerKeysFilter) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("search", func(e uri.Encoder) error {
		if val, ok := s.Search.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"search\"")
	}
	if err := e.EncodeField("state", func(e uri.Encoder) error {
		if val, ok := s.State.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"state\"")
	}
	return nil
}

var uriFieldsNameOfGetPipelineTriggerKeysFilter = [2]string{
	0: "search",
	1: "state",
}

// DecodeURI decodes GetPipelineTriggerKeysFilter from URI form.
func (s *GetPipelineTriggerKeysFilter) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetPipelineTriggerKeysFilter to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "search":
			if err := func() error {
				var sDotSearchVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotSearchVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Search.SetTo(sDotSearchVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"search\"")
			}
		case "state":
			if err := func() error {
				var sDotStateVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotStateVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.State.SetTo(sDotStateVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"state\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetPipelineTriggerKeysFilter")
	}

	return nil
}

// EncodeURI encodes GetPipelineTriggerKeysPage as URI form.
func (s *GetPipelineTriggerKeysPage) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("number", func(e uri.Encoder) error {
		if val, ok := s.Number.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"number\"")
	}
	if err := e.EncodeField("size", func(e uri.Encoder) error {
		if val, ok := s.Size.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"size\"")
	}
	return nil
}

var uriFieldsNameOfGetPipelineTriggerKeysPage = [2]string{
	0: "number",
	1: "size",
}

// DecodeURI decodes GetPipelineTriggerKeysPage from URI form.
func (s *GetPipelineTriggerKeysPage) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetPipelineTriggerKeysPage to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "number":
			if err := func() error {
				var sDotNumberVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotNumberVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Number.SetTo(sDotNumberVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"number\"")
			}
		case "size":
			if err := func() error {
				var sDotSizeVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotSizeVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Size.SetTo(sDotSizeVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"size\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetPipelineTriggerKeysPage")
	}

	return nil
}

// EncodeURI encodes GetPipelinesFilter as URI form.
func (s *GetPipelinesFilter) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("identifier", func(e uri.Encoder) error {
		if val, ok := s.Identifier.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"identifier\"")
	}
	if err := e.EncodeField("search", func(e uri.Encoder) error {
		if val, ok := s.Search.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"search\"")
	}
	if err := e.EncodeField("state", func(e uri.Encoder) error {
		if val, ok := s.State.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"state\"")
	}
	return nil
}

var uriFieldsNameOfGetPipelinesFilter = [3]string{
	0: "identifier",
	1: "search",
	2: "state",
}

// DecodeURI decodes GetPipelinesFilter from URI form.
func (s *GetPipelinesFilter) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetPipelinesFilter to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "identifier":
			if err := func() error {
				var sDotIdentifierVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotIdentifierVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Identifier.SetTo(sDotIdentifierVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"identifier\"")
			}
		case "search":
			if err := func() error {
				var sDotSearchVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotSearchVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Search.SetTo(sDotSearchVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"search\"")
			}
		case "state":
			if err := func() error {
				var sDotStateVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotStateVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.State.SetTo(sDotStateVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"state\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetPipelinesFilter")
	}

	return nil
}

// EncodeURI encodes GetPipelinesPage as URI form.
func (s *GetPipelinesPage) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("number", func(e uri.Encoder) error {
		if val, ok := s.Number.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"number\"")
	}
	if err := e.EncodeField("size", func(e uri.Encoder) error {
		if val, ok := s.Size.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"size\"")
	}
	return nil
}

var uriFieldsNameOfGetPipelinesPage = [2]string{
	0: "number",
	1: "size",
}

// DecodeURI decodes GetPipelinesPage from URI form.
func (s *GetPipelinesPage) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetPipelinesPage to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "number":
			if err := func() error {
				var sDotNumberVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotNumberVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Number.SetTo(sDotNumberVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"number\"")
			}
		case "size":
			if err := func() error {
				var sDotSizeVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotSizeVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Size.SetTo(sDotSizeVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"size\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetPipelinesPage")
	}

	return nil
}

// EncodeURI encodes GetProviderLocationsPage as URI form.
func (s *GetProviderLocationsPage) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("number", func(e uri.Encoder) error {
		if val, ok := s.Number.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"number\"")
	}
	if err := e.EncodeField("size", func(e uri.Encoder) error {
		if val, ok := s.Size.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"size\"")
	}
	return nil
}

var uriFieldsNameOfGetProviderLocationsPage = [2]string{
	0: "number",
	1: "size",
}

// DecodeURI decodes GetProviderLocationsPage from URI form.
func (s *GetProviderLocationsPage) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetProviderLocationsPage to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "number":
			if err := func() error {
				var sDotNumberVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotNumberVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Number.SetTo(sDotNumberVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"number\"")
			}
		case "size":
			if err := func() error {
				var sDotSizeVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotSizeVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Size.SetTo(sDotSizeVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"size\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetProviderLocationsPage")
	}

	return nil
}

// EncodeURI encodes GetProviderServersFilter as URI form.
func (s *GetProviderServersFilter) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("location_ids", func(e uri.Encoder) error {
		if val, ok := s.LocationIds.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"location_ids\"")
	}
	return nil
}

var uriFieldsNameOfGetProviderServersFilter = [1]string{
	0: "location_ids",
}

// DecodeURI decodes GetProviderServersFilter from URI form.
func (s *GetProviderServersFilter) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetProviderServersFilter to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "location_ids":
			if err := func() error {
				var sDotLocationIdsVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotLocationIdsVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.LocationIds.SetTo(sDotLocationIdsVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"location_ids\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetProviderServersFilter")
	}

	return nil
}

// EncodeURI encodes GetProviderServersPage as URI form.
func (s *GetProviderServersPage) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("number", func(e uri.Encoder) error {
		if val, ok := s.Number.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"number\"")
	}
	if err := e.EncodeField("size", func(e uri.Encoder) error {
		if val, ok := s.Size.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"size\"")
	}
	return nil
}

var uriFieldsNameOfGetProviderServersPage = [2]string{
	0: "number",
	1: "size",
}

// DecodeURI decodes GetProviderServersPage from URI form.
func (s *GetProviderServersPage) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetProviderServersPage to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "number":
			if err := func() error {
				var sDotNumberVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotNumberVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Number.SetTo(sDotNumberVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"number\"")
			}
		case "size":
			if err := func() error {
				var sDotSizeVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotSizeVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Size.SetTo(sDotSizeVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"size\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetProviderServersPage")
	}

	return nil
}

// EncodeURI encodes GetProvidersFilter as URI form.
func (s *GetProvidersFilter) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("search", func(e uri.Encoder) error {
		if val, ok := s.Search.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"search\"")
	}
	if err := e.EncodeField("state", func(e uri.Encoder) error {
		if val, ok := s.State.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"state\"")
	}
	return nil
}

var uriFieldsNameOfGetProvidersFilter = [2]string{
	0: "search",
	1: "state",
}

// DecodeURI decodes GetProvidersFilter from URI form.
func (s *GetProvidersFilter) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetProvidersFilter to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "search":
			if err := func() error {
				var sDotSearchVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotSearchVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Search.SetTo(sDotSearchVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"search\"")
			}
		case "state":
			if err := func() error {
				var sDotStateVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotStateVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.State.SetTo(sDotStateVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"state\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetProvidersFilter")
	}

	return nil
}

// EncodeURI encodes GetProvidersPage as URI form.
func (s *GetProvidersPage) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("number", func(e uri.Encoder) error {
		if val, ok := s.Number.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"number\"")
	}
	if err := e.EncodeField("size", func(e uri.Encoder) error {
		if val, ok := s.Size.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"size\"")
	}
	return nil
}

var uriFieldsNameOfGetProvidersPage = [2]string{
	0: "number",
	1: "size",
}

// DecodeURI decodes GetProvidersPage from URI form.
func (s *GetProvidersPage) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetProvidersPage to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "number":
			if err := func() error {
				var sDotNumberVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotNumberVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Number.SetTo(sDotNumberVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"number\"")
			}
		case "size":
			if err := func() error {
				var sDotSizeVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotSizeVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Size.SetTo(sDotSizeVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"size\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetProvidersPage")
	}

	return nil
}

// EncodeURI encodes GetRecordsCollectionFilter as URI form.
func (s *GetRecordsCollectionFilter) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("state", func(e uri.Encoder) error {
		if val, ok := s.State.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"state\"")
	}
	return nil
}

var uriFieldsNameOfGetRecordsCollectionFilter = [1]string{
	0: "state",
}

// DecodeURI decodes GetRecordsCollectionFilter from URI form.
func (s *GetRecordsCollectionFilter) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetRecordsCollectionFilter to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "state":
			if err := func() error {
				var sDotStateVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotStateVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.State.SetTo(sDotStateVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"state\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetRecordsCollectionFilter")
	}

	return nil
}

// EncodeURI encodes GetRecordsCollectionPage as URI form.
func (s *GetRecordsCollectionPage) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("number", func(e uri.Encoder) error {
		if val, ok := s.Number.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"number\"")
	}
	if err := e.EncodeField("size", func(e uri.Encoder) error {
		if val, ok := s.Size.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"size\"")
	}
	return nil
}

var uriFieldsNameOfGetRecordsCollectionPage = [2]string{
	0: "number",
	1: "size",
}

// DecodeURI decodes GetRecordsCollectionPage from URI form.
func (s *GetRecordsCollectionPage) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetRecordsCollectionPage to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "number":
			if err := func() error {
				var sDotNumberVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotNumberVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Number.SetTo(sDotNumberVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"number\"")
			}
		case "size":
			if err := func() error {
				var sDotSizeVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotSizeVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Size.SetTo(sDotSizeVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"size\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetRecordsCollectionPage")
	}

	return nil
}

// EncodeURI encodes GetSecurityReportFilter as URI form.
func (s *GetSecurityReportFilter) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("range-start", func(e uri.Encoder) error {
		if val, ok := s.RangeMinusStart.Get(); ok {
			if unwrapped := time.Time(val); true {
				return e.EncodeValue(conv.DateTimeToString(unwrapped))
			}
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"range-start\"")
	}
	if err := e.EncodeField("range-end", func(e uri.Encoder) error {
		if val, ok := s.RangeMinusEnd.Get(); ok {
			if unwrapped := time.Time(val); true {
				return e.EncodeValue(conv.DateTimeToString(unwrapped))
			}
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"range-end\"")
	}
	if err := e.EncodeField("environment", func(e uri.Encoder) error {
		if val, ok := s.Environment.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"environment\"")
	}
	if err := e.EncodeField("event", func(e uri.Encoder) error {
		if val, ok := s.Event.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"event\"")
	}
	return nil
}

var uriFieldsNameOfGetSecurityReportFilter = [4]string{
	0: "range-start",
	1: "range-end",
	2: "environment",
	3: "event",
}

// DecodeURI decodes GetSecurityReportFilter from URI form.
func (s *GetSecurityReportFilter) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetSecurityReportFilter to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "range-start":
			if err := func() error {
				var sDotRangeMinusStartVal DateTime
				if err := func() error {
					var sDotRangeMinusStartValVal time.Time
					if err := func() error {
						val, err := d.DecodeValue()
						if err != nil {
							return err
						}

						c, err := conv.ToDateTime(val)
						if err != nil {
							return err
						}

						sDotRangeMinusStartValVal = c
						return nil
					}(); err != nil {
						return err
					}
					sDotRangeMinusStartVal = DateTime(sDotRangeMinusStartValVal)
					return nil
				}(); err != nil {
					return err
				}
				s.RangeMinusStart.SetTo(sDotRangeMinusStartVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"range-start\"")
			}
		case "range-end":
			if err := func() error {
				var sDotRangeMinusEndVal DateTime
				if err := func() error {
					var sDotRangeMinusEndValVal time.Time
					if err := func() error {
						val, err := d.DecodeValue()
						if err != nil {
							return err
						}

						c, err := conv.ToDateTime(val)
						if err != nil {
							return err
						}

						sDotRangeMinusEndValVal = c
						return nil
					}(); err != nil {
						return err
					}
					sDotRangeMinusEndVal = DateTime(sDotRangeMinusEndValVal)
					return nil
				}(); err != nil {
					return err
				}
				s.RangeMinusEnd.SetTo(sDotRangeMinusEndVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"range-end\"")
			}
		case "environment":
			if err := func() error {
				var sDotEnvironmentVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotEnvironmentVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Environment.SetTo(sDotEnvironmentVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"environment\"")
			}
		case "event":
			if err := func() error {
				var sDotEventVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotEventVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Event.SetTo(sDotEventVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"event\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetSecurityReportFilter")
	}

	return nil
}

// EncodeURI encodes GetServerInstancesPage as URI form.
func (s *GetServerInstancesPage) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("number", func(e uri.Encoder) error {
		if val, ok := s.Number.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"number\"")
	}
	if err := e.EncodeField("size", func(e uri.Encoder) error {
		if val, ok := s.Size.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"size\"")
	}
	return nil
}

var uriFieldsNameOfGetServerInstancesPage = [2]string{
	0: "number",
	1: "size",
}

// DecodeURI decodes GetServerInstancesPage from URI form.
func (s *GetServerInstancesPage) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetServerInstancesPage to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "number":
			if err := func() error {
				var sDotNumberVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotNumberVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Number.SetTo(sDotNumberVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"number\"")
			}
		case "size":
			if err := func() error {
				var sDotSizeVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotSizeVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Size.SetTo(sDotSizeVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"size\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetServerInstancesPage")
	}

	return nil
}

// EncodeURI encodes GetServerTagsFilter as URI form.
func (s *GetServerTagsFilter) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("cluster", func(e uri.Encoder) error {
		if val, ok := s.Cluster.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"cluster\"")
	}
	return nil
}

var uriFieldsNameOfGetServerTagsFilter = [1]string{
	0: "cluster",
}

// DecodeURI decodes GetServerTagsFilter from URI form.
func (s *GetServerTagsFilter) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetServerTagsFilter to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "cluster":
			if err := func() error {
				var sDotClusterVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotClusterVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Cluster.SetTo(sDotClusterVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cluster\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetServerTagsFilter")
	}

	return nil
}

// EncodeURI encodes GetServerTelemetryFilter as URI form.
func (s *GetServerTelemetryFilter) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("range-start", func(e uri.Encoder) error {
		if val, ok := s.RangeMinusStart.Get(); ok {
			if unwrapped := time.Time(val); true {
				return e.EncodeValue(conv.DateTimeToString(unwrapped))
			}
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"range-start\"")
	}
	if err := e.EncodeField("range-end", func(e uri.Encoder) error {
		if val, ok := s.RangeMinusEnd.Get(); ok {
			if unwrapped := time.Time(val); true {
				return e.EncodeValue(conv.DateTimeToString(unwrapped))
			}
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"range-end\"")
	}
	return nil
}

var uriFieldsNameOfGetServerTelemetryFilter = [2]string{
	0: "range-start",
	1: "range-end",
}

// DecodeURI decodes GetServerTelemetryFilter from URI form.
func (s *GetServerTelemetryFilter) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetServerTelemetryFilter to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "range-start":
			if err := func() error {
				var sDotRangeMinusStartVal DateTime
				if err := func() error {
					var sDotRangeMinusStartValVal time.Time
					if err := func() error {
						val, err := d.DecodeValue()
						if err != nil {
							return err
						}

						c, err := conv.ToDateTime(val)
						if err != nil {
							return err
						}

						sDotRangeMinusStartValVal = c
						return nil
					}(); err != nil {
						return err
					}
					sDotRangeMinusStartVal = DateTime(sDotRangeMinusStartValVal)
					return nil
				}(); err != nil {
					return err
				}
				s.RangeMinusStart.SetTo(sDotRangeMinusStartVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"range-start\"")
			}
		case "range-end":
			if err := func() error {
				var sDotRangeMinusEndVal DateTime
				if err := func() error {
					var sDotRangeMinusEndValVal time.Time
					if err := func() error {
						val, err := d.DecodeValue()
						if err != nil {
							return err
						}

						c, err := conv.ToDateTime(val)
						if err != nil {
							return err
						}

						sDotRangeMinusEndValVal = c
						return nil
					}(); err != nil {
						return err
					}
					sDotRangeMinusEndVal = DateTime(sDotRangeMinusEndValVal)
					return nil
				}(); err != nil {
					return err
				}
				s.RangeMinusEnd.SetTo(sDotRangeMinusEndVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"range-end\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetServerTelemetryFilter")
	}

	return nil
}

// EncodeURI encodes GetServerTelemetryPage as URI form.
func (s *GetServerTelemetryPage) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("number", func(e uri.Encoder) error {
		if val, ok := s.Number.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"number\"")
	}
	if err := e.EncodeField("size", func(e uri.Encoder) error {
		if val, ok := s.Size.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"size\"")
	}
	return nil
}

var uriFieldsNameOfGetServerTelemetryPage = [2]string{
	0: "number",
	1: "size",
}

// DecodeURI decodes GetServerTelemetryPage from URI form.
func (s *GetServerTelemetryPage) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetServerTelemetryPage to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "number":
			if err := func() error {
				var sDotNumberVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotNumberVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Number.SetTo(sDotNumberVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"number\"")
			}
		case "size":
			if err := func() error {
				var sDotSizeVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotSizeVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Size.SetTo(sDotSizeVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"size\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetServerTelemetryPage")
	}

	return nil
}

// EncodeURI encodes GetServersCollectionFilter as URI form.
func (s *GetServersCollectionFilter) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("state", func(e uri.Encoder) error {
		if val, ok := s.State.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"state\"")
	}
	if err := e.EncodeField("tags", func(e uri.Encoder) error {
		if val, ok := s.Tags.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"tags\"")
	}
	if err := e.EncodeField("clusters", func(e uri.Encoder) error {
		if val, ok := s.Clusters.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"clusters\"")
	}
	if err := e.EncodeField("providers", func(e uri.Encoder) error {
		if val, ok := s.Providers.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"providers\"")
	}
	return nil
}

var uriFieldsNameOfGetServersCollectionFilter = [4]string{
	0: "state",
	1: "tags",
	2: "clusters",
	3: "providers",
}

// DecodeURI decodes GetServersCollectionFilter from URI form.
func (s *GetServersCollectionFilter) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetServersCollectionFilter to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "state":
			if err := func() error {
				var sDotStateVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotStateVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.State.SetTo(sDotStateVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"state\"")
			}
		case "tags":
			if err := func() error {
				var sDotTagsVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotTagsVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Tags.SetTo(sDotTagsVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"tags\"")
			}
		case "clusters":
			if err := func() error {
				var sDotClustersVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotClustersVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Clusters.SetTo(sDotClustersVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"clusters\"")
			}
		case "providers":
			if err := func() error {
				var sDotProvidersVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotProvidersVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Providers.SetTo(sDotProvidersVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"providers\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetServersCollectionFilter")
	}

	return nil
}

// EncodeURI encodes GetServersCollectionPage as URI form.
func (s *GetServersCollectionPage) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("number", func(e uri.Encoder) error {
		if val, ok := s.Number.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"number\"")
	}
	if err := e.EncodeField("size", func(e uri.Encoder) error {
		if val, ok := s.Size.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"size\"")
	}
	return nil
}

var uriFieldsNameOfGetServersCollectionPage = [2]string{
	0: "number",
	1: "size",
}

// DecodeURI decodes GetServersCollectionPage from URI form.
func (s *GetServersCollectionPage) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetServersCollectionPage to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "number":
			if err := func() error {
				var sDotNumberVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotNumberVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Number.SetTo(sDotNumberVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"number\"")
			}
		case "size":
			if err := func() error {
				var sDotSizeVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotSizeVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Size.SetTo(sDotSizeVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"size\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetServersCollectionPage")
	}

	return nil
}

// EncodeURI encodes GetSourcesCollectionFilter as URI form.
func (s *GetSourcesCollectionFilter) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("identifier", func(e uri.Encoder) error {
		if val, ok := s.Identifier.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"identifier\"")
	}
	if err := e.EncodeField("search", func(e uri.Encoder) error {
		if val, ok := s.Search.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"search\"")
	}
	if err := e.EncodeField("state", func(e uri.Encoder) error {
		if val, ok := s.State.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"state\"")
	}
	return nil
}

var uriFieldsNameOfGetSourcesCollectionFilter = [3]string{
	0: "identifier",
	1: "search",
	2: "state",
}

// DecodeURI decodes GetSourcesCollectionFilter from URI form.
func (s *GetSourcesCollectionFilter) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetSourcesCollectionFilter to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "identifier":
			if err := func() error {
				var sDotIdentifierVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotIdentifierVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Identifier.SetTo(sDotIdentifierVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"identifier\"")
			}
		case "search":
			if err := func() error {
				var sDotSearchVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotSearchVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Search.SetTo(sDotSearchVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"search\"")
			}
		case "state":
			if err := func() error {
				var sDotStateVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotStateVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.State.SetTo(sDotStateVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"state\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetSourcesCollectionFilter")
	}

	return nil
}

// EncodeURI encodes GetSourcesCollectionPage as URI form.
func (s *GetSourcesCollectionPage) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("number", func(e uri.Encoder) error {
		if val, ok := s.Number.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"number\"")
	}
	if err := e.EncodeField("size", func(e uri.Encoder) error {
		if val, ok := s.Size.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"size\"")
	}
	return nil
}

var uriFieldsNameOfGetSourcesCollectionPage = [2]string{
	0: "number",
	1: "size",
}

// DecodeURI decodes GetSourcesCollectionPage from URI form.
func (s *GetSourcesCollectionPage) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetSourcesCollectionPage to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "number":
			if err := func() error {
				var sDotNumberVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotNumberVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Number.SetTo(sDotNumberVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"number\"")
			}
		case "size":
			if err := func() error {
				var sDotSizeVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotSizeVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Size.SetTo(sDotSizeVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"size\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetSourcesCollectionPage")
	}

	return nil
}

// EncodeURI encodes GetStackBuildsFilter as URI form.
func (s *GetStackBuildsFilter) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("search", func(e uri.Encoder) error {
		if val, ok := s.Search.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"search\"")
	}
	if err := e.EncodeField("state", func(e uri.Encoder) error {
		if val, ok := s.State.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"state\"")
	}
	return nil
}

var uriFieldsNameOfGetStackBuildsFilter = [2]string{
	0: "search",
	1: "state",
}

// DecodeURI decodes GetStackBuildsFilter from URI form.
func (s *GetStackBuildsFilter) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetStackBuildsFilter to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "search":
			if err := func() error {
				var sDotSearchVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotSearchVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Search.SetTo(sDotSearchVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"search\"")
			}
		case "state":
			if err := func() error {
				var sDotStateVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotStateVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.State.SetTo(sDotStateVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"state\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetStackBuildsFilter")
	}

	return nil
}

// EncodeURI encodes GetStackBuildsPage as URI form.
func (s *GetStackBuildsPage) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("number", func(e uri.Encoder) error {
		if val, ok := s.Number.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"number\"")
	}
	if err := e.EncodeField("size", func(e uri.Encoder) error {
		if val, ok := s.Size.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"size\"")
	}
	return nil
}

var uriFieldsNameOfGetStackBuildsPage = [2]string{
	0: "number",
	1: "size",
}

// DecodeURI decodes GetStackBuildsPage from URI form.
func (s *GetStackBuildsPage) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetStackBuildsPage to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "number":
			if err := func() error {
				var sDotNumberVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotNumberVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Number.SetTo(sDotNumberVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"number\"")
			}
		case "size":
			if err := func() error {
				var sDotSizeVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotSizeVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Size.SetTo(sDotSizeVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"size\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetStackBuildsPage")
	}

	return nil
}

// EncodeURI encodes GetStacksFilter as URI form.
func (s *GetStacksFilter) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("identifier", func(e uri.Encoder) error {
		if val, ok := s.Identifier.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"identifier\"")
	}
	if err := e.EncodeField("search", func(e uri.Encoder) error {
		if val, ok := s.Search.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"search\"")
	}
	if err := e.EncodeField("state", func(e uri.Encoder) error {
		if val, ok := s.State.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"state\"")
	}
	return nil
}

var uriFieldsNameOfGetStacksFilter = [3]string{
	0: "identifier",
	1: "search",
	2: "state",
}

// DecodeURI decodes GetStacksFilter from URI form.
func (s *GetStacksFilter) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetStacksFilter to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "identifier":
			if err := func() error {
				var sDotIdentifierVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotIdentifierVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Identifier.SetTo(sDotIdentifierVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"identifier\"")
			}
		case "search":
			if err := func() error {
				var sDotSearchVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotSearchVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Search.SetTo(sDotSearchVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"search\"")
			}
		case "state":
			if err := func() error {
				var sDotStateVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotStateVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.State.SetTo(sDotStateVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"state\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetStacksFilter")
	}

	return nil
}

// EncodeURI encodes GetStacksPage as URI form.
func (s *GetStacksPage) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("number", func(e uri.Encoder) error {
		if val, ok := s.Number.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"number\"")
	}
	if err := e.EncodeField("size", func(e uri.Encoder) error {
		if val, ok := s.Size.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"size\"")
	}
	return nil
}

var uriFieldsNameOfGetStacksPage = [2]string{
	0: "number",
	1: "size",
}

// DecodeURI decodes GetStacksPage from URI form.
func (s *GetStacksPage) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetStacksPage to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "number":
			if err := func() error {
				var sDotNumberVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotNumberVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Number.SetTo(sDotNumberVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"number\"")
			}
		case "size":
			if err := func() error {
				var sDotSizeVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotSizeVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Size.SetTo(sDotSizeVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"size\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetStacksPage")
	}

	return nil
}

// EncodeURI encodes GetUsableServersPage as URI form.
func (s *GetUsableServersPage) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("number", func(e uri.Encoder) error {
		if val, ok := s.Number.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"number\"")
	}
	if err := e.EncodeField("size", func(e uri.Encoder) error {
		if val, ok := s.Size.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"size\"")
	}
	return nil
}

var uriFieldsNameOfGetUsableServersPage = [2]string{
	0: "number",
	1: "size",
}

// DecodeURI decodes GetUsableServersPage from URI form.
func (s *GetUsableServersPage) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetUsableServersPage to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "number":
			if err := func() error {
				var sDotNumberVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotNumberVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Number.SetTo(sDotNumberVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"number\"")
			}
		case "size":
			if err := func() error {
				var sDotSizeVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotSizeVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Size.SetTo(sDotSizeVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"size\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetUsableServersPage")
	}

	return nil
}

// EncodeURI encodes GetVpnLoginsPage as URI form.
func (s *GetVpnLoginsPage) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("number", func(e uri.Encoder) error {
		if val, ok := s.Number.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"number\"")
	}
	if err := e.EncodeField("size", func(e uri.Encoder) error {
		if val, ok := s.Size.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"size\"")
	}
	return nil
}

var uriFieldsNameOfGetVpnLoginsPage = [2]string{
	0: "number",
	1: "size",
}

// DecodeURI decodes GetVpnLoginsPage from URI form.
func (s *GetVpnLoginsPage) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetVpnLoginsPage to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "number":
			if err := func() error {
				var sDotNumberVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotNumberVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Number.SetTo(sDotNumberVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"number\"")
			}
		case "size":
			if err := func() error {
				var sDotSizeVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotSizeVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Size.SetTo(sDotSizeVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"size\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetVpnLoginsPage")
	}

	return nil
}

// EncodeURI encodes GetZonesCollectionFilter as URI form.
func (s *GetZonesCollectionFilter) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("state", func(e uri.Encoder) error {
		if val, ok := s.State.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"state\"")
	}
	return nil
}

var uriFieldsNameOfGetZonesCollectionFilter = [1]string{
	0: "state",
}

// DecodeURI decodes GetZonesCollectionFilter from URI form.
func (s *GetZonesCollectionFilter) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetZonesCollectionFilter to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "state":
			if err := func() error {
				var sDotStateVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotStateVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.State.SetTo(sDotStateVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"state\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetZonesCollectionFilter")
	}

	return nil
}

// EncodeURI encodes GetZonesCollectionPage as URI form.
func (s *GetZonesCollectionPage) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("number", func(e uri.Encoder) error {
		if val, ok := s.Number.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"number\"")
	}
	if err := e.EncodeField("size", func(e uri.Encoder) error {
		if val, ok := s.Size.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"size\"")
	}
	return nil
}

var uriFieldsNameOfGetZonesCollectionPage = [2]string{
	0: "number",
	1: "size",
}

// DecodeURI decodes GetZonesCollectionPage from URI form.
func (s *GetZonesCollectionPage) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GetZonesCollectionPage to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "number":
			if err := func() error {
				var sDotNumberVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotNumberVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Number.SetTo(sDotNumberVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"number\"")
			}
		case "size":
			if err := func() error {
				var sDotSizeVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotSizeVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Size.SetTo(sDotSizeVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"size\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GetZonesCollectionPage")
	}

	return nil
}

// EncodeURI encodes ListScopedVariablesFilter as URI form.
func (s *ListScopedVariablesFilter) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("identifier", func(e uri.Encoder) error {
		if val, ok := s.Identifier.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"identifier\"")
	}
	if err := e.EncodeField("search", func(e uri.Encoder) error {
		if val, ok := s.Search.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"search\"")
	}
	if err := e.EncodeField("state", func(e uri.Encoder) error {
		if val, ok := s.State.Get(); ok {
			return e.EncodeValue(conv.StringToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"state\"")
	}
	return nil
}

var uriFieldsNameOfListScopedVariablesFilter = [3]string{
	0: "identifier",
	1: "search",
	2: "state",
}

// DecodeURI decodes ListScopedVariablesFilter from URI form.
func (s *ListScopedVariablesFilter) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ListScopedVariablesFilter to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "identifier":
			if err := func() error {
				var sDotIdentifierVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotIdentifierVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Identifier.SetTo(sDotIdentifierVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"identifier\"")
			}
		case "search":
			if err := func() error {
				var sDotSearchVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotSearchVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Search.SetTo(sDotSearchVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"search\"")
			}
		case "state":
			if err := func() error {
				var sDotStateVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					sDotStateVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.State.SetTo(sDotStateVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"state\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode ListScopedVariablesFilter")
	}

	return nil
}

// EncodeURI encodes ListScopedVariablesPage as URI form.
func (s *ListScopedVariablesPage) EncodeURI(e uri.Encoder) error {
	if err := e.EncodeField("number", func(e uri.Encoder) error {
		if val, ok := s.Number.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"number\"")
	}
	if err := e.EncodeField("size", func(e uri.Encoder) error {
		if val, ok := s.Size.Get(); ok {
			return e.EncodeValue(conv.Float64ToString(val))
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "encode field \"size\"")
	}
	return nil
}

var uriFieldsNameOfListScopedVariablesPage = [2]string{
	0: "number",
	1: "size",
}

// DecodeURI decodes ListScopedVariablesPage from URI form.
func (s *ListScopedVariablesPage) DecodeURI(d uri.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ListScopedVariablesPage to nil")
	}

	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
		switch k {
		case "number":
			if err := func() error {
				var sDotNumberVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotNumberVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Number.SetTo(sDotNumberVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"number\"")
			}
		case "size":
			if err := func() error {
				var sDotSizeVal float64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToFloat64(val)
					if err != nil {
						return err
					}

					sDotSizeVal = c
					return nil
				}(); err != nil {
					return err
				}
				s.Size.SetTo(sDotSizeVal)
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"size\"")
			}
		default:
			return nil
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode ListScopedVariablesPage")
	}

	return nil
}